La classe mint est un entier n'ayant pas de maximum

Soyez le premier à donner votre avis sur cette source.

Snippet vu 4 382 fois - Téléchargée 31 fois

Contenu du snippet

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;

  • 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(); }

Conclusion :


C'est magnifique !!!!
N'est ce pas ?

A voir également

Ajouter un commentaire

Commentaires

sibi12
Messages postés
337
Date d'inscription
jeudi 19 décembre 2002
Statut
Membre
Dernière intervention
15 avril 2006
-
Salut,

bonne idée !!

j'ai voulu faire y a un petit temps la même chose en assembleur mais avec une autre structure. je voulais mettre 2 ou 4 octets avec le nombre d'octet du nombre codé et puis les octet codant ce nombre
enfin soit

J'ai lu en vitesse la source et j'ai juste une question.
si j'ai bien compris tu utilise une liste chainée d'entier représentant un nombre de 0 à 9 pour représenter un nombre entier. mais t'as une grosse perte de mémoire à cause de ça. tu utilise 32bit pour coder un nombre codable sur 4 donc ta classe est très facilement améliorable. donc pourquoi pas travailler sur des char en avec des nombres de 0 à 0xff. ça demande un peu plus de travial mais ton code serai mieu "standardiser" même si on est loin très loin du compte

Tu pouvais aussi utiliser la STL pour alléger ton code
je crois aussi que quelque ligne d'assembleur pourrait fare des merveille ici

donc beaucoup de chose à améliorer sinon bonne idée

allez salut
cs_Kirua
Messages postés
3006
Date d'inscription
dimanche 14 avril 2002
Statut
Membre
Dernière intervention
31 décembre 2008
-
operator= doit retourner une référence sur l'objet:

&MINT operator= { ... return *this; }

il y a trop de pertes si j'en crois le message de sibi, tu pourrais stocker le nombre sur un nombre variable de bits grâce aux bools dans une liste chaînée (enfin, plus simplement avec list, ou vector de la STL)
monssif007
Messages postés
3
Date d'inscription
vendredi 30 mars 2007
Statut
Membre
Dernière intervention
4 juin 2010
-
bonne idée ,mais bon ta pas fait le constructeur de copie pour la la classe fille MINT aussi que le destructeur^^

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.