linked lists polynomial help

[Cassandra Walke]

I am having trouble writing my c++ code for a polynomial
I need help with istream and operator*

Here is my code:
[

#include "polynomial.h"
#include <iostream>
 
using namespace std;
 
polynomial::polynomial()
{
    head=NULL;
}
 
polynomial::polynomial(const polynomial& p)
{
    {
    node<term>* otherNode = p.head;
 
    while (otherNode != NULL){
        orderedInsert(otherNode->data.coef, otherNode->data.expn);
        otherNode = otherNode->next;
    }
}
 
polynomial::~polynomial()
{
    node<term> *nextNode = head, *deadNode = NULL;
 
    while(nextNode != head){
        deadNode = nextNode;
        nextNode = nextNode->next;
        delete &deadNode;
    }
}
 
polynomial& polynomial::operator=( const polynomial& p )
{
    return *this;
}
 
double polynomial::evaluate ( double x )
{
    double sum=0;
    term* currentTerm=head;
    while(currentTerm !=NULL)
    {
        sum += currentTerm->coef * pow(x, currentTerm->expn);
        currentTerm=currentTerm->next;
    }
    return sum;
}
int polynomial::degree() const
{
    return head->expn;
}
 
void polynomial::orderedInsert(double n, int e) {
    {
        if(head == NULL){
            head = new node<term>(term(n, e), NULL);
        }else{
 
            node<term>* p1 = head;
            node<term>* p2 = p1;
            while ( p1 != NULL && n > p1->data.expn )
            {
                p2 = p1;
                p1 = p1->next;
            }
            if ( p1 != NULL )
            {
                if ( p1->data.expn == e){
                    p1->data.coef += n;
                }else if ( p1 == head)
                {
                    head = new node<term>(term(n, e), NULL);
                }
                else
                {
                    p2->next = new node<term>(term(n, e), NULL);
                }
            }else{
                p2->next = new node<term>(term(n, e), p2);
            }
        }
    }
}
 
polynomial polynomial::operator+ ( const polynomial& p) const
{
    polynomial result;
    node<term>* reader = p.head;
    while (reader != NULL){
        result.orderedInsert(reader->data.coef, reader->data.expn);
        reader = reader->next;
    }
    reader = head;
    while (reader != NULL){
        result.orderedInsert(reader->data.coef, reader->data.expn);
        reader = reader->next;
    }
    return result;
}
 
  polynomial polynomial::operator- ( const polynomial& p ) const
{
    polynomial result;
    node<term> *reader = p.head;
    while (reader != NULL){
        result.orderedInsert(-(reader->data.coef), reader->data.expn);
        reader = reader->next;
    }
    reader = head;
    while (reader != NULL){
        result.orderedInsert(reader->data.coef, reader->data.expn);
        reader = reader->next;
    }
    return result;
}
 
 
polynomial polynomial::operator* ( const polynomial& p ) const
{
    polynomial result;
    return result;
}
 
ostream& operator<< ( ostream& os, const polynomial& )
{
    node<term> *printer = poly.head;
    while(printer != NULL){
        os << printer->toString(os);
        if(printer->nextPoint() != NULL){
            os << " + ";
        }
    }
    return os;
}
 
 
istream& operator>> ( istream& is, polynomial& p )
{
    return is;
}

]


Thanks so much

[weaknessforcats]

Is there some reason why you are not using std::list instead of writing your own linked list code?