I am new to this site and it was recommended by a friend and class mate. I am having serious issues in OOP. Did great in C++ last semester but our new book is killing me. I am trying to get this program going with polynomials. The professor gave us his prototypes and main, which I think has confused me more than if I'd written it myself.

The problem wants us to use dynamic arrays to implement a polynomial class with +, -, and *. I am having trouble grasping hold of the overloaded operators mainly but input on anything else would be helpful. Here is what I have so far. May have some silly errors in it yet though. Any help is greatly appreciated.

```
#include <iostream>
using namespace std;
#include <cstdlib>
class Polynomial
{
private:
double * coef;
int size;
public:
Polynomial(); // creates an empty polynomial
Polynomial(const Polynomial & p); // copy ctor
// size of the coefficient array is degree of the polynomial + 1
Polynomial(double coefnt[], int size);
~Polynomial();
// use as r-value to inspect coefficient, as l-value to assign coefficient;
double & operator[](int degree); // required for 'const' correctness
const double & operator[](int degree)const;
//const Polynomial & operator=(const Polynomial & p);
int getSize();
//double eval(double arg) const; // evaluate polynomial for arg
Polynomial operator+(const Polynomial & p);
Polynomial operator-(const Polynomial & p);
Polynomial operator*(const Polynomial & p);
};
int main()
{
double one[] = {1};
Polynomial One(one, 1);
double quad[] = {3, -2.1, 1.3};
double cubic[] = {1, 2, 0, 3.2};
Polynomial q(quad, 3); // q is 3 - 2.1*x + 1.3*x*x
Polynomial c(cubic, 4); // c is 1 + 2*x + 0*x*x + 3.2*x*x*x
Polynomial p(q); // test copy constructor
cout << " value of q(2) is " << q.eval(2) << endl;
cout << " value of p(2) is " << p.eval(2) << endl;
Polynomial r;
r = c; //test operator=
cout << " value of r(2) is " << r.eval(2) << endl;
cout << " value of c(2) is " << c.eval(2) << endl;
cout << "\nPolynomial q " << endl;
for ( int k = 0; k < q.getSize(); k++ )
cout << " term with degree " << k << " has coefnt " << q[k] << endl;
cout << "\nPolynomial c " << endl;
for ( int k = 0; k < c.getSize(); k++ )
cout << " term with degree " << k << " has coefnt " << c[k] << endl;
r = q + c; // test operator+
cout << "\nPolynomial r (= q + c) " << endl;
for ( int k = 0; k < r.getSize(); k++ )
cout << " term with degree " << k << " has coefnt " << r[k] << endl;
cout << " value of (q + c)(2) is " << r.eval(2) << endl;
r = q - c; // test operator-
cout << "\nPolynomial r (= q - c) " << endl;
for ( int k = 0; k < r.getSize(); k++ )
cout << " term with degree " << k << " has coefnt " << r[k] << endl;
cout << " value of (q - c)(2) is " << r.eval(2) << endl;
r = q * c; // test operator*
cout << " size of q*c is " << r.getSize() << endl;
cout << "\nPolynomial r (= q * c) " << endl;
for ( int k = 0; k < r.getSize(); k++ )
cout << " term with degree " << k << " has coefnt " << r[k] << endl;
cout << " value of (q * c)(2) is " << r.eval(2) << endl;
return 0;
}
Polynomial::Polynomial()
{//creates an empty polynomial
size = 0;
coef = new double[size+1];
coef[0] = 0;
}
//copy constructor
Polynomial::Polynomial(const Polynomial & p)
{
size = p.size;
coef = new double[size+1];
for (int i = 0; i <= size; i++)
coef[i] = p.coef[i];
}
Polynomial::Polynomial(double coefnt[], int size)
{
size = p.size;
coef = new double[size+1];
for (int i = 0; i <= size; i++)
coef[i] = p.coef[i];
}
//destructor
Polynomial::~Polynomial()
{
delete [] coef;
}
//overloaded []
double Polynomial::& operator[](int degree) // required for 'const' correctness
{
if (degree < 0)
{
cout << "Invalid input";
exit(1);
}
else if (degree > size)
{
cout << "Out of bounds";
exit(1);
}
else
return size;
}
/*
const double Polynomial::& operator[](int degree)const
{
}
*/
const Polynomial & operator=(const Polynomial & p)
{
if ((size != p.size)
{
delete [] coef;
coef= new double[p.size];
for (int i = 0; i < size; i++)
coef[p.size] = new double[size];
}
sizes = p.size;
assert(coef != NULL);
for (int i=0; i < size; i++)
coef[i] = p.coef[i];
return *this;
}
int Polynomial:: getSize()
{
return size;
}
/*double Polynomial::eval(double arg) const // evaluate polynomial for arg
{
}
*/
Polynomial::Polynomial operator+(const Polynomial & p)
{
}
Polynomial::Polynomial operator-(const Polynomial & p)
{
}
Polynomial::Polynomial operator*(const Polynomial & p)
{
}
```