#ifndef Poly_H
#define Poly_H

#include <stdio.h>
#include <iostream.h>

class Poly
{
   public:
      Poly(int* const intptr, int nzero);    // constructor
      Poly(const Poly&);                     // copy constructor
      int degree();
      int getpol() const { return *pol }
      void display() const;
      Poly operator+ (const Poly&);          // operator overload to add 2 polys
      Poly operator* (const Poly&);          // operator overload to multiply 
      Poly operator= (const Poly&);          // assignment overload
      
   private:
      int *pol;                              // points to first element
};

#endif

#include "Poly.h"
#include <iostream.h>

Poly::Poly(int * const intptr, int nzero)
{}


Poly::Poly(const Poly& rhs)
{
   pol = new int;
   *pol = rhs.getpol();
}


int Poly::degree()
{
   return (*pol);
}


Poly Poly::operator+ (const Poly & rhs)
{
   


void Poly::display() const
{
   int *p = pol + 1;
   int d = degree(),e=d;
   if (e == 0)
   {
      cout << "(0 " << *p << ")" << "\n";
      return;
   }
   cout << "(";
   while (d >= 0)
   {
      if (*p != 0)
      {
         if (d < e) cout << ", ";
         cout << d << "  " << *p;
      }
      d--; p++;
   }
   cout << ")\n";
}




           

/*
   This file defines all the exception classes that may be
   thrown by the program.
*/

#ifndef EXCEPTIONCLASS_H
#define EXCEPTIONCLASS_H

#include <string>

class wrongData
{ public:
     wrongData(const string& msg)
        /* purpose: constructor to create a wrongData exception object.
           parameters: msg -- the error message.
           requirement: None.
           promise: the error message has been sent.
           exception: No.
        */
      :err(msg)  {}

      string errorMsg() {return err;}
         /* purpose: to return the stored error message.
            parameters: No.
            requirement: None.
            promise: the error message is returned.
            exception: No.
         */
   private:
      string err;   // the error message
};

#endif
       

// DO NOT MODIFY OR CHANGE THE CONTENTS OF THIS FILE.  YOUR CLASS/CODE
// MUST COMPILE WITH THE GIVEN CODE AS IS.
// Test program for testing class Poly

#include <iostream.h>
#include <stdlib.h>
#include <string>

#include "exceptionClass.h"
#include "Poly.h"

int* cinPoly(int& len);

void main()
{
   cout << "A simple program for testing polynomial\n";
   
   string option = "2";
   while (option != "1")
   {
      cout << "----------------------------------------\n";
      cout << "choose:\n";
      cout << "1   (to exit)\n";
      cout << "2   (to add two polynomials, p1+p2)\n";
      cout << "3   (to multiply two polynomials, p1*p2)\n";
      cout << "4   (p1*p2+p3)\n";
      cout << "5   (p1+p2+p3)\n";

      cin >> option;
      switch (int choice = atoi(option.c_str()))
      {
         case 1:
            break;
         case 2: case 3: case 4: case 5:
         {
            int *temp1 = NULL, *temp2 = NULL, *temp3 = NULL;
            Poly *poly1 = NULL, *poly2 = NULL, *poly3 = NULL;
            try
            {
               int len;
               cout << "Please input the first polynomial:" << endl;
               temp1 = cinPoly(len);
               poly1 = new Poly(temp1,len);
               (*poly1).display();
               cout << "Please input the second polynomial:" << endl;
               temp2 = cinPoly(len);
               poly2 = new Poly(temp2,len);
               (*poly2).display();

               Poly res;

               if (choice == 2)
                  res = *poly1 + *poly2;
               else if (choice == 3)
                  res = *poly1 * *poly2;
               else
               {
                  cout << "Please input the third polynomial:" << endl;
                  temp3 = cinPoly(len);
                  poly3 = new Poly(temp3, len);
                  (*poly3).display();
                  if (choice == 4)
                     res = *poly1 * *poly2 + *poly3;
                  else
                  {
                     Poly tempRes(*poly1 + *poly2 + *poly3);
                     res = tempRes;
                  }
               }
                  cout << "result = ";
                  res.display();
                  delete temp1; delete temp2; delete temp3;
                  delete poly1; delete poly2; delete poly3;
            }
            catch (wrongData& a)
            {
               delete temp1; delete temp2; delete temp3;
               delete poly1; delete poly2; delete poly3;
               cout << a.errorMsg();
            }
            break;
         }
         default:
            cout << "ERROR: invalid input: " << option << "\n";
            break; 
      }   // end case
   } // end while
   cout << "program exited successfully" << endl;
} //end main

int* cinPoly(int& len)
{
   cout << "Please input the # of non zero terms in the polynomial:";
   cin >> len;
   int len2 = 2 * len;
   // programming error: no checking on len, if < -1, program will 
abort.
   // It is because the length of an array cannot be negative.
   int* res = new int[len2];
   if(len != 0)
      cout << " Please input the non zero terms of the polynomial: 
degree, coefficient:" << endl;
   for (int i = 0; i < len2; i++)
      cin >> res[i];
   return res;
}

int* cinPoly(int& len)
{
    .
    .
    .

    int* res = new int[len2]; // this is where the array is created

    // the loop below is where the contents are assigned
    if(len != 0)
        cout << " Please input the non zero terms of the polynomial: degree, coefficient:" << endl;
    for (int i = 0; i < len2; i++)
        cin >> res[i];
    return res;
}

Poly::Poly(int * const intptr, int nzero)
{
    int len = 2 * nzero;  // array must contain degree & coeff for each term

    pol = new int[len];  // see how we create a dynamic array, like above?
    // note: at this point the array contents are uninitialized,
    // which means that the array contains "garbage"

    // this loop is analogous to the one in cinPoly
    // except that we are copying from one array to another,
    // instead of reading from cin
    for (int i = 0; i < len; ++i)
        pol[i] = intptr[i];
}

pol = new int [len];

Poly::Poly(const Poly& rhs)               // implementation of copy constructor
{
   pol = new int[len];
   int* npol = rhs.getpol();
   
   
   for (int i = 0; i < len; i++)
      pol[i] = npol[i]; 
}