$-$Add to polynomial.h appropriate declarations of iterator and const$\_$iterator types and associated functions allowing access to a Polynomial object$$s terms.

$-$Replace the indexing$-$based code in polynomial.cpp with iterator$-$based code.

Polynomial.h file

#ifndef POLYNOMIAL$\_$H

#define POLYNOMIAL$\_$H

#include

#include

#include

#include "term.h$"$

class Polynomial $\{$

public:

Polynomial$()$;

Polynomial $($int b$,$ int a $=0)$;

Polynomial $($std::initializer$\_$list terms$)$;

Polynomial $($int nCoeff, int coeff$[])$;

int getCoeff$($int power$)$ const;

int getDegree$()$ const;

Polynomial operator$+($const Polynomial& p$)$ const;

Polynomial operator$*($int scale$)$ const;

Polynomial operator$*($Term term$)$ const;

void operator$*=($int scale$)$;

Polynomial operator$/($const Polynomial& p$)$ const;

bool operator$==($const Polynomial& p$)$ const;

private:

int degree;

std::list terms;

void normalize$()$;

friend std::ostream& operator$<<($std::ostream&$,$ const Polynomial&$)$;

$\}$;

std::ostream& operator$<<($std::ostream&$,$ const Polynomial&$)$;

inline Polynomial operator$*($int by$,$ const Polynomial& p$)$

$\{$return p $*$ by;$\}$

inline bool operator!$=($const Polynomial& p$,$ const Polynomial& q$)$

$\{$return $!($p $==$ q$)$;$\}$

#endif

Polynomial.cpp file

#include "polynomial.h$"$

#include

#include

using namespace std;

void Polynomial::normalize $()$

$\{$

if $($degree $<0)$

$\{$

terms.clear$()$;

return;

$\}$

std::list::iterator it $=$ terms.begin$()$;

while $($it $!=$ terms.end$())$

$\{$

if $($it$->$coefficient $==0)$

it $=$ terms.erase$($it$)$;

else

$++$it;

$\}$

if $($terms$.$begin$()!=$ terms.end$())$

degree $=$ terms.back$().$power;

else

degree $=0$;

$\}$

Polynomial::Polynomial $()$

: degree$(-1),$ coefficients$($nullptr$)$

$\{$

$\}$

Polynomial::Polynomial $($int b$,$ int a$)$

: degree$(1),$ coefficients$($new int$[2])$

$\{$

coefficients$[0]=$ b;

coefficients$[1]=$ a;

normalize$()$;

$\}$

Polynomial::Polynomial $($Term term$)$

: degree$($term$.$power$),$ coefficients$($new int$[$term$.$power$+1])$

$\{$

for $($int i $=0$; i $<$ degree; $++$i$)$

coefficients$[$i$]=0$;

coefficients$[$degree$]=$ term.coefficient;

normalize$()$;

$\}$

Polynomial::Polynomial $($int nC$,$ int coeff$[])$

: degree$($nC$-1),$ coefficients$($new int$[$nC$])$

$\{$

for $($int i $=0$; i $<=$ degree; $++$i$)$

coefficients$[$i$]=$ coeff$[$i$]$;

normalize$()$;

$\}$

void Polynomial::normalize $()$

$\{$

while $($degree$+1>1$ && coefficients$[$degree$]==0)$

$--$degree;

$\}$

int Polynomial::getDegree$()$ const

$\{$

return degree;

$\}$

int Polynomial::getCoeff$($int power$)$ const

$\{$

if $($power $>=0$ && power $<=$ degree$)$

$\{$

return coefficients$[$power$]$;

$\}$

else

$\{$

return $0\mathrm{.}0$;

$\}$

$\}$

Polynomial Polynomial::operator$+($const Polynomial& p$)$ const

$\{$

if $($degree $==-1||$ p$.$degree $==-1)$

return Polynomial$()$;

int resultSize $=$ max$($degree$+1,$ p$.$degree$+1)$;

int$*$ resultCoefficients $=$ new int$[$resultSize$]$;

int k $=0$;

while $($k $<=$ getDegree$()$ && k $<=$ p$.$getDegree$())$

$\{$

resultCoefficients$[$k$]=$ coefficients$[$k$]+$ p$.$coefficients$[$k$]$;

$++$k;

$\}$

for $($int i $=$ k; i $<=$ getDegree$()$; $++$i$)$

resultCoefficients$[$i$]=$ coefficients$[$i$]$;

for $($int i $=$ k; i $<=$ p$.$getDegree$()$; $++$i$)$

resultCoefficients$[$i$]=$ p$.$coefficients$[$i$]$;

Polynomial result$($resultSize$,$ resultCoefficients$)$;

delete$[]$ resultCoefficients;

return result;

$\}$

Polynomial Polynomial::operator$*($int scale$)$ const

$\{$

if $($degree $==-1)$

return Polynomial$()$;

Polynomial result $(*$this$)$;

for $($int i $=0$; i $<=$ degree; $++$i$)$

result.coefficients$[$i$]=$ scale $*$ coefficients$[$i$]$;

result.normalize$()$;

return result;

$\}$

Polynomial Polynomial::operator$*($Term term$)$ const

$\{$

if $($degree $==-1)$

return Polynomial$()$;

int$*$ results $=$ new int$[$degree $+1+$ term.power$]$;

for $($int i $=0$; i $<$ term.power; $++$i$)$

results$[$i$]=0$;

for $($int i $=0$; i $<$ degree $+1$; $++$i$)$

results$[$i$+$term.power$]=$ coefficients$[$i$]*$ term.coefficient;

Polynomial result $($degree $+1+$ term.power, results$)$;

delete $[]$ results;

return result;

$\}$

void Polynomial::operator$*=($int scale$)$

$\{$

if $($degree $==-1)$

return;

for $($int i $=0$; i $<=$ degree; $++$i$)$

coefficients$[$i$]=$ scale $*$ coefficients$[$i$]$;

normalize$()$;

$\}$

Polynomial Polynomial::operator$/($const Polynomial& denominator$)$ const

$\{$

if $($degree $==-1||$ denominator.degree $==-1)$

return Polynomial$()$;

if $(*$this $==$ Polynomial$(0))$

return $*$this;

if $($denominator$.$getDegree$()>$ getDegree$())$

return Polynomial$()$;

int resultSize $=$ degree $-$ denominator.degree $+1$;

int$*$ results $=$ new int$[$resultSize$]$;

for $($int i $=0$; i $<$ resultSize; $++$i$)$

results$[$i$]=0$;

Polynomial remainder $=*$this;

for $($int i $=$ resultSize$-1$; i $>=0$; $--$i$)$

$\{$

int remainder$1$stCoeff $=$ remainder.getCoeff$($i$+$denominator.getDegree$())$;

int denominator$1$stCoeff $=$ denominator.getCoeff$($denominator$.$getDegree$())$;

if $($remainder$1$stCoeff $\%$ denominator$1$stCoeff $==0)\{$

results$[$i$]=$ remainder$1$stCoeff $/$ denominator$1$stCoeff;

Polynomial subtractor $=$ denominator $*$ Term$(-$results$[$i$],$ i$)$;

remainder $=$ remainder $+$ subtractor;

$\}$ else $\{$

break;

$\}$

$\}$

if $($remainder $==$ Polynomial$(0))\{$

Polynomial result $($resultSize$,$ results$)$;

delete $[]$ results;

return result;

$\}$

else

$\{$

delete $[]$ results;

return Polynomial$()$;

$\}$

$\}$