LA CLASSE MINT EST UN ENTIER N'AYANT PAS DE MAXIMUM

#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;
		*precedent=copie;
		if (x.current==origine)
		current=copie;
		origine=origine->precedent;
		precedent=&(copie->precedent);
	}
	*precedent=NULL;
}
////////////////////////////////////////////////////////////////
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)
{
*this=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)
{
*this=*this+x;
}
////////////////////////////////////////////////////////////////
void mint::operator+=(int x)
{
*this=*this+x;
}
////////////////////////////////////////////////////////////////
void mint::operator++()
{
*this=*this+1;
}
////////////////////////////////////////////////////////////////
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();
}