La Classe MINT est un entier n'ayant pas de maximum
Avec tous les opérateurs du type Int
Ou du moin les plus importants
Source / Exemple :
#include<conio.h>
#include<iostream.h>
#include<string.h>
class liste_entier
{
protected:
struct listes
{
int valeur;
listes *precedent;
}*liste,*nb,*current;
public:
liste_entier()
{
nb=NULL;
current=NULL;
}
liste_entier(liste_entier &);
void addtofront(int);
void addtoend(int);
void movefirst();
void movelast();
void movepreview();
void movenext();
int getcurrent();
int size();
void clear();
~liste_entier(){clear();};
};
////////////////////////////////////////////////////////////////
liste_entier::liste_entier(liste_entier &x)
{
listes *origine,*copie,**precedent;
origine=x.nb;
precedent=&nb;
current=NULL;
while (origine)
{
copie=new listes;
copie->valeur=origine->valeur;
if (x.current==origine)
current=copie;
origine=origine->precedent;
precedent=&(copie->precedent);
}
}
////////////////////////////////////////////////////////////////
void liste_entier::addtofront(int valeur)
{
liste=new listes;
current=nb;
if(nb==NULL) addtoend(valeur);
else
{
while(current->precedent!=NULL) current=current->precedent;
liste->valeur=valeur;
liste->precedent=NULL;
current->precedent=liste;
}
}
////////////////////////////////////////////////////////////////
void liste_entier::addtoend(int valeur)
{
liste=new listes;
if(nb==NULL) {
liste->precedent=NULL;
liste->valeur=valeur;
nb=liste;
}
else {
liste->precedent=nb;
liste->valeur=valeur;
nb=liste;
}
current=nb;
}
////////////////////////////////////////////////////////////////
void liste_entier::movefirst()
{
while(current->precedent!=NULL) current=current->precedent;
}
////////////////////////////////////////////////////////////////
void liste_entier::movelast()
{
current=nb;
}
////////////////////////////////////////////////////////////////
void liste_entier::movepreview()
{
if(current->precedent!=NULL)
current=current->precedent;
}
////////////////////////////////////////////////////////////////
void liste_entier::movenext()
{
if(current!=nb)
{
listes *tmp;
tmp=nb;
while(tmp->precedent!=current) {tmp=tmp->precedent;}
current=tmp;
}
}
////////////////////////////////////////////////////////////////
int liste_entier::getcurrent()
{
return current->valeur;
}
////////////////////////////////////////////////////////////////
int liste_entier::size()
{
int compt=0;
listes *tmp;
tmp=nb;
while(tmp!=NULL) {
compt++;
tmp=tmp->precedent;
}
return compt;
}
////////////////////////////////////////////////////////////////
void liste_entier::clear()
{
current=nb;
while(current!=NULL)
{
current=current->precedent;
delete nb;
nb=current;
}
}
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
class mint :public liste_entier
{
public:
//mint(){};
mint(char * = 0);
void saisie(char *);
void affichage();
void operator=(mint);
void operator=(int);
void operator+=(mint);
void operator+=(int);
void operator++();
friend mint operator+(mint,mint);
friend mint operator+(mint,int);
friend mint operator+(int,mint);
int mintcomp(mint,mint);
float convertfloat();
};
////////////////////////////////////////////////////////////////
mint::mint(char *x)
{
int i=0,c=0;
clear();
for(i=0;i<strlen(x);i++)
if(x[i]-'0'!=0) break;
else c++;
for(i=c;i<strlen(x);i++)
{
addtoend(x[i]-'0');
}
}
////////////////////////////////////////////////////////////////
void mint::saisie(char *x)
{
}
////////////////////////////////////////////////////////////////
void mint::affichage()
{
if(nb!=NULL)
{
int i;
listes *tmp;
tmp=current;
movefirst();
for(i=0;i<size();i++)
{
cout<<getcurrent();
movenext();
}
current=tmp;
}
}
////////////////////////////////////////////////////////////////
void mint::operator=(mint x)
{
int i;
clear();
x.movefirst();
for(i=0;i<x.size();i++)
{
addtoend(x.getcurrent());
x.movenext();
}
}
////////////////////////////////////////////////////////////////
void mint::operator=(int x)
{
clear();
while(x/10!=0)
{
addtofront(x%10);
x=x/10;
}
addtofront(x%10);
}
////////////////////////////////////////////////////////////////
mint operator+(mint x,mint y)
{
int max=0,min=0,i,a,reste=0,comp=0;
mint z;
if(x.size()==y.size())
{
min=x.size();
max=y.size();
}
else
if(x.size()>y.size())
{
max=x.size();
min=y.size();
comp=1;
}
else
if(x.size()<y.size())
{
max=y.size();
min=x.size();
comp=2;
}
x.movelast();
y.movelast();
for(i=0;i<min;i++)
{
a=x.getcurrent()+y.getcurrent()+reste;
reste=a/10;
z.addtofront(a%10);
x.movepreview();
y.movepreview();
}
if(comp==1)
for(i=min;i<max;i++)
{
a=x.getcurrent()+reste;
reste=a/10;
z.addtofront(a%10);
x.movepreview();
y.movepreview();
}
else
if(comp==2)
for(i=min;i<max;i++)
{
a=y.getcurrent()+reste;
reste=a/10;
z.addtofront(a%10);
x.movepreview();
y.movepreview();
}
if(reste==1) z.addtofront(1);
return z;
}
////////////////////////////////////////////////////////////////
void mint::operator+=(mint x)
{
}
////////////////////////////////////////////////////////////////
void mint::operator+=(int x)
{
}
////////////////////////////////////////////////////////////////
void mint::operator++()
{
}
////////////////////////////////////////////////////////////////
mint operator+(mint x,int y)
{
mint z;
z=y;
return (z+x);
}
////////////////////////////////////////////////////////////////
mint operator+(int x,mint y)
{
mint z;
z=x;
return (z+y);
}
////////////////////////////////////////////////////////////////
int mintcomp(mint x,mint y)
{
int i;
if(x.size()>y.size()) return 1;
else
if(x.size()<y.size()) return -1;
else
{
x.movefirst();
y.movefirst();
for(i=0;i<x.size();i++)
{
if(x.getcurrent()>y.getcurrent()) return 1;
else
if(x.getcurrent()<y.getcurrent()) return -1;
else {
x.movenext();
y.movenext();
}
}
return 0;
}
}
////////////////////////////////////////////////////////////////
float mint::convertfloat()
{
float new_val=0,i;
movefirst();
for(i=0;i<size();i++)
{
new_val=(new_val*10)+getcurrent();
movenext();
}
return new_val;
}
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
void main()
{
clrscr();
mint x("123"),y;
y=x+15;
y.affichage();
getch();
}
Conclusion :
C'est magnifique !!!!
N'est ce pas ?
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.