Listes chaînées, polynômes, opérateurs surchargés << and >> en C++

Question

Je dois construire un polynôme de classe (polinom) hérité de class lista (list). Je dois ajouter, soustraire, multiplier, diviser 2 objets de la classe polynom. J'ai ce code. Je ne comprends pas pourquoi mes destructeurs ne fonctionnent pas. Je dois aussi surcharger les opérateurs: +, -, < <, >> mais je ne sais pas comment.

#include <iostream> 
#include <conio.h> 

using namespace std; 

struct nod 
{float coef; 
int grad; 
nod* adr_urm; 
}; 

class lista 
{ 
public: 
    nod *vf,*sf; 
    lista(); 
    nod* adaug(nod *&vf,nod*& sf , int gr,float cf); 
    void afis(nod* vz); 
    ~lista(); 
}; 

class polinom : public lista 
{public: 
polinom(); 
~polinom(); 

}; 




void lista::afis(nod* vz) 
{nod *c=vz; 
cout<<"Elementele polinomului"<<endl; 
int i=0; 
while (c) 

{if (i) cout<<"+"; 
cout<<c->coef<<"X^"<<c->grad; 
c=c->adr_urm; 
i++; 
} 
cout<<endl<<endl; 
} 

nod* lista::adaug(nod *&vf,nod*& sf ,int gr,float cf) 
{ nod *c=new nod; 
c->coef=cf; 
c->grad=gr; 
c->adr_urm=0; 
if (vf==0) vf=sf=c; 
else {sf->adr_urm=c; 
     sf=c;} 
return vf; 
} 

lista::lista() 
{vf=0; 
} 

polinom::polinom() 
{vf=0; 
} 

lista::~lista() 
{nod *m=vf, *m1=vf->adr_urm; 
while (m1) 
     {delete m; 
     m=m1; 
     m1=m->adr_urm; 
     } 
vf=0; 
} 

polinom::~polinom() 
{nod *man=vf, *man1=vf->adr_urm; 
while (man1) 
     {delete man; 
     man=man1; 
     man1=man->adr_urm; 
     } 
vf=NULL; 
} 




int main() 
{ 
int m,nr,nr1; 
float n; 
nod* vf=0 ;nod *sf; 
nod* varFl=0 ;nod *varFv=0; 

polinom l,v; 

cout<<"Nr de elemente primul pol nr= "; 
cin>>nr; 
for (int i=1;i<=nr;i++) 
{ cout<<"Elementul "<<i<<endl; 
    cout<<"Coeficientul = "; 
    cin>>n; 
    cout<<"Gradul = "; 
    cin>>m; 
    l.adaug(vf,sf,m,n); 
    varFl=vf; 
} 
l.afis(varFl); 

vf=0; 

cout<<"Nr de elemente al doilea pol nr= "; 
cin>>nr1; 
for (int j=1;j<=nr1;j++) 
{cout<<"Elementul "<<j<<endl; 
cout<<"Coeficientul = "; 
cin>>n; 
cout<<"Gradul = "; 
cin>>m; 
v.adaug(vf,sf,m,n); 
varFv=vf; 
} 
v.afis(varFv); 

l.~polinom(); 
v.~polinom(); 
_getch(); 


} 

Answer 1

Est-ce une question de devoirs? Pour un, votre destructeur dans la liste n'est pas virtuel, mais un plus gros problème est que votre destructeur dans polynom est juste un copier-coller de celui dans lista.

Je pense que vous avez vraiment besoin de revoir votre conception et le code ici ...

Answer 2

travaillent Votre Destructeurs probablement bien, mais vous les appelez deux fois, et le deuxième appel provoque probablement segfaults. Il suffit de supprimer les appels comme

l.~polinom() 

de votre code; les destructeurs sont appelés automatiquement.

Ensuite, vous n'avez pas besoin de copier le destructeur lista dans polinom; le destructeur de la classe de base est appelé automatiquement aussi.

Answer 3

En supposant que "polinom" signifie "polynomial" alors vous avez un défaut de conception de base - un polynôme n'est pas une liste chaînée. Vous devriez utiliser l'utilisation du confinement plutôt que de l'héritage pour exprimer qu'un polynôme peut être implémenté en termes de liste chaînée.

Answer 4

Vous devriez avoir deux classes: une classe monomiale qui résume un seul terme avec un coefficient et un exposant et un polynôme qui a une liste de monomères comme membre de données privées. Le monomial vous permettra seulement d'ajouter ou de soustraire des termes dont les exposants sont égaux; le résultat sera un monôme qui a le même exposant et la somme ou la différence des coefficients. Le résultat des méthodes mul et div sera également un monôme qui a comme coefficient le produit ou le quotient des coefficients et comme exposant la somme ou le nombre des exposants.

Les méthodes polynomiales parcourront sa liste de monômes pour effectuer les opérations arithmétiques. Je suis d'accord avec le commentaire qui vous déconseille d'étendre un conteneur comme liste chaînée. Ceci est mieux exprimé sous la forme d'une liste polynomiale HAS-A de monômes plutôt que d'une liste IS-A de monômes. C'est une différence subtile et importante.

Un avantage de HAS-A est qu'il vous permettra de modifier la structure de données que vous utilisez pour stocker les monômes sans affecter les clients. Tableau, liste, carte - votre utilisateur s'en fout, tant que vous respectez le contrat. Je ne sais pas s'il y a un avantage à traiter les monômes et les polynômes de la même façon, mais si vous voulez une interface définissant des méthodes communes et un pattern GoF Composite.