Question

I’m working on a problem which requires me to use the STL linked list class to represent a polynomials. I’ve made a good start on getting the class definition, however I’m a little confused as to where to go next (novice programmer – please excuse my potential ignorance).

class Polynomial
{
    public:
        Polynomial(); //Default constructor
        Polynomial(pair<double,int>); //Specified constructor
        void add(Polynomial);
        Polynomial multiply(Polynomial);
        void print();
    private:
        list<int> order_terms;
        list<double> coeffs;
};

I have two questions:

1) It seems more elegant to store the terms and coefficients as a pair – however I’m unsure how to get that working using the STL list.

2) Regarding the add member function, I’m unsure how to implement it such that I can define a Polynomial and then add terms to it like this:

Polynomial test(pair<3.14,0>);
Polynomial test_2(pair<2,1>);
test.add(test_2);

The main thing I’m having issues with understanding how to access the terms stored in the other object and linking it to the first Polynomial.

Any help greatly appreciated.

EDIT: Code for the add() function – currently not working

void Polynomial::add(const Polynomial& rhs)
{
//Perform some sort of sort here to make sure both lists are correctly sorted
//Traverse the list of terms to see if there's an existing nth order
//term in the list on the left-hand-side polynomial.
list<int>::iterator itr;
list<int>::iterator itl;
for(itr=rhs->terms.begin(); itr!=rhs->terms.end(); itr++)
{
    bool match=0;
    //See if there's an existing terms, if so add to it
    for(itl=terms.begin(); itl!=terms.end(); itl++)
    {
        if(*itl->second)==*itr->second)
        {
            *itl->first+=*itr->first;
            match = 1;
         }      
    }

    //If not, this is the first nth order term so just push it onto the list
    if(!match){ terms.push_back(*itr); //Perform the sort again }         
}

Answer 1

Others have explained list<pair<double, int> > (and I like shelleybutterfly’s suggestion to derive Polynomial from the list, except that I’d make it protected, not public, so that outside code is not too free to mess with the contents of the list).

But the add function is a little tricky, because adding two polynomials doesn’t generally mean concatenating them or adding their terms together. The operation is actually more like merging— and you’ll soon see that the lists must be sorted. (In fact, it’s more natural to represent polynomials as vectors, but I guess that’s not the assignment.)

I suggest you implement Polynomial::add(pair<double, int>), first, then implement the other one (add(Polynomial &)) in terms of that.

I don’t want to spell it out too much, since this looks like homework. Is this enough to point you in the right direction?

EDIT:
Your new code looks correct (albeit inefficient) if you fix a couple of bugs:

void Polynomial::add(const Polynomial& rhs)
{
  // Don't forget to implement the sorting routine.

  // The iterators must be of the correct type. And itr must be const,
  // since you have declared rhs to be a const reference. The compiler
  // will not allow you to have an iterator with the power to alter
  // a const thing.

  list<pair<double,int> >::const_iterator itr;
  list<pair<double,int> >::iterator itl;

  for(itr=rhs->terms.begin(); itr!=rhs->terms.end(); itr++)
    {
      bool match=false;
      for(itl=terms.begin(); itl!=terms.end(); itl++)
        {
          // You have an extra parenthesis here, and too much dereferencing.
          if(itl->second == itr->second)
            {
              itl->first+=itr->first;
              match = true;
            }
        }
      if(!match)
        { terms.push_back(*itr); //Perform the sort again
        } // Be careful not to catch the closing brace in a comment
    }
  }

Once it is working, you can think about ways to make it cleaner and more efficient. For example, if you insert the new term in the right place, the list will always be in the right order and there will be no need for a sort routine.