Hey there, I'm having trouble figuring out the next step of my program. What I'm trying to do is make a function that will add two polynomials, and I don't know how to exactly fix it. My first question would be if the Polynomial operator+ function is right, or whether it needs some fixing. Any hints or advice would be appreciated. Here's my code:

``````/*-- Polynomial.h ---------------------------------------------------------
Defines the monomial and polynomial classes. Polynomial is implemented
basically as a list of monomials.
---------------------------------------------------------------------------*/

#include <iostream>

#ifndef PNOM
#define PNOM

const int CAPACITY = 1024;
//typedef int ElementType;

class Monomial {
private:
float coef;
int		exp;
public:
Monomial(){};
/*----------------------------------------------------------------------
Construct a Monomial object.

Precondition:  None
Postcondition: An empty Monomial object has been constructed..
-----------------------------------------------------------------------*/
Monomial(float c,int p) { coef = c; exp = p;};
/*----------------------------------------------------------------------
Construct a Monomial object with specified coeffient and exponent.

Precondition:  None
Postcondition: A Monomial object has been constructed with the
specified coeffient and exponent.
-----------------------------------------------------------------------*/
friend Monomial operator+ (Monomial &, Monomial &);
/*----------------------------------------------------------------------

Precondition:  The monomials have the same exponent.
Postcondition: A Monomial object has been created and returned.
-----------------------------------------------------------------------*/
friend ostream & operator<< (ostream & out, const Monomial & mono);
/*----------------------------------------------------------------------

Precondition:  None.
Postcondition: The coefficient and exponent (if != 0) of the monomial are
displayed in the default output device.
-----------------------------------------------------------------------*/
};

typedef Monomial ElementType;

class Polynomial
{
public:

Polynomial();
/*----------------------------------------------------------------------
Construct a List object.

Precondition:  None
Postcondition: An empty List object has been constructed; mySize is 0.
-----------------------------------------------------------------------*/

/***** empty operation *****/
bool empty() const;
/*----------------------------------------------------------------------
Check if a list is empty.

Precondition:  None
Postcondition: true is returned if the list is empty, false if not.
-----------------------------------------------------------------------*/

/***** insert and erase *****/
void insert(ElementType item, int pos);
/*----------------------------------------------------------------------
Insert a value into the list at a given position.

Precondition:  item is the value to be inserted; there is room in
the array (mySize < CAPACITY); and the position satisfies
0 <= pos <= mySize.
Postcondition: item has been inserted into the list at the position
determined by pos (provided there is room and pos is a legal
position).
-----------------------------------------------------------------------*/

void erase(int pos);
/*----------------------------------------------------------------------
Remove a value from the list at a given position.

Precondition:  The list is not empty and the position satisfies
0 <= pos < mySize.
Postcondition: element at the position determined by pos has been
removed (provided pos is a legal position).
----------------------------------------------------------------------*/

/***** output *****/
void display(ostream & out) const;
/*----------------------------------------------------------------------
Display a list.

Precondition:  The ostream out is open.
Postcondition: The list represented by this List object has been
inserted into out.
-----------------------------------------------------------------------*/

friend Polynomial operator+(Polynomial &, Polynomial &);
Polynomial SubstractPoly(Polynomial &);
Polynomial MultiplyPoly(Polynomial &);

private:
int mySize;                     // current size of list stored in myArray
ElementType myArray[CAPACITY];  // array to store the Monomials

}; //--- end of List class

//------ Prototype of output operator
ostream & operator<< (ostream & out, const Polynomial & p);

#endif``````
``````/*-- Polynomial.cpp------------------------------------------------------------

This file implements List member functions.

-------------------------------------------------------------------------*/

#include <cassert>
using namespace std;

#include "Polynomial.h"

/*----------------------------------------------------------------------
Member and friend functions for Monomial.
-----------------------------------------------------------------------*/

Monomial operator+ (Monomial& a, Monomial& b) {
Monomial res;
res.coef	= a.coef + b.coef;
res.exp	= a.exp;
return res;
}

ostream & operator<< (ostream & out, const Monomial & mono)
{
out << mono.coef ;
if (mono.exp > 0) out << "x^" << mono.exp;
return out;
}

/*----------------------------------------------------------------------
Member and friend functions for Polinomial.
-----------------------------------------------------------------------*/

Polynomial::Polynomial()
: mySize(0)
{}

bool Polynomial::empty() const
{
return mySize == 0;
}

void Polynomial::display(ostream & out) const
{
for (int i = mySize-1; i >= 0 ; i--) {
if (i != mySize-1) out << " + ";
out << myArray[i];
}

}

ostream & operator<< (ostream & out, const Polynomial & aList)
{
aList.display(out);
return out;
}

void Polynomial::insert(ElementType item, int pos)
{
if (mySize == CAPACITY)
{
cerr << "*** No space for list element -- terminating "
"execution ***\n";
exit(1);
}
if (pos < 0 || pos > mySize)
{
cerr << "*** Illegal location to insert -- " << pos
<< ".  List unchanged. ***\n";
return;
}

// First shift array elements right to make room for item

for(int i = mySize; i > pos; i--)
myArray[i] = myArray[i - 1];

// Now insert item at position pos and increase list size
myArray[pos] = item;
mySize++;
}

void Polynomial::erase(int pos)
{
if (mySize == 0)
{
cerr << "*** List is empty ***\n";
return;
}
if (pos < 0 || pos >= mySize)
{
cerr << "Illegal location to delete -- " << pos
<< ".  List unchanged. ***\n";
return;
}

// Shift array elements left to close the gap
for(int i = pos; i < mySize; i++)
myArray[i] = myArray[i + 1];

// Decrease list size
mySize--;
}

Polynomial operator+(Polynomial &p1, Polynomial &p2){
Polynomial res;
Monomial resP;
int i = 0;

if(p1.exp == p2.exp)
resP.coef = p1.coef + p2.coef;

for(i = 0; i < p1.mySize; i++){
resP.myArray[i] = p1.myArray[i] + p2.myArray;
}
res.mySize = p1.mySize + p2.mySize;

return res;

}

/*
Polynomial Polynomial::SubstractPolynomials(Polynomial &p){
Polynomial res;

for(int i = 0; i < mySize; i++){
res.myArray[i] = myArray[i];
}
for(int j = 0; j < p.mySize; j++){
res.myArray[j+i] = p.myArray[j];
}
res.p3 = mySize - p.mySize;

return res;
}

Polynomial Polynomial::MultiplyPolynomials(Polynomial &p){
Polynomial res;

for(int i = 0; i < mySize; i++){
res.myArray[i] = myArray[i];
}
for(int j = 0; j < p.mySize; j++){
res.myArray[j+i] = p.myArray[j];
}
res.p3 = mySize * p.mySize;

return res;
}*/``````
Be a part of the DaniWeb community

We're a friendly, industry-focused community of 1.21 million developers, IT pros, digital marketers, and technology enthusiasts learning and sharing knowledge.