why am i getting std error and AddressSanitizer: heap$-$use$-$after$-$free error? #include "polynomial.h$"$

#include

#include

#include

#include

#include

using namespace std;

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$()$;

$\}$

$//$ Constructor for a single term polynomial

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

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

$\{$

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

coefficients$[$i$]=0$;

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

normalize$()$;

$\}$

$//$ Constructor for a polynomial with given coefficients

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

: degree$($nCoeff $-1),$ coefficients$($new int$[$nCoeff$])\{$

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

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

normalize$()$;

$\}$

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

$\{$

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

$\{$

return coefficients$[$power$]$;

$\}$

else

$\{$

return $0$;

$\}$

$\}$

$//$ Destructor

Polynomial::~Polynomial$()$

$\{$

delete$[]$ coefficients;

$\}$

int Polynomial::getDegree$()$ const

$\{$

return degree;

$\}$

void Polynomial::normalize $()$

$\{$

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

$--$degree;

$\}$

$//$ Addition of polynomials

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

if $($degree $<0||$ p$.$degree $<0)$

return Polynomial$()$;

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

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

int k $=0$;

while $($k $<=$ degree && k $<=$ p$.$degree$)\{$

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

$++$k;

$\}$

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

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

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

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

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

return result;

$\}$

$//$ Scalar multiplication

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;

$\}$

$//$ Multiplication by a single term

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; $++$i$)$

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

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

delete$[]$ results;

return result;

$\}$

$//$ Scalar assignment

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

if $($degree $==1)$

return;

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

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

normalize$()$;

$\}$

$//$ Polynomial division

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$]()$;

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 $\{$

delete$[]$ results;

return Polynomial$()$;

$\}$

$\}$

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

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

delete$[]$ results;

return result;

$\}$ else $\{$

delete$[]$ results;

return Polynomial$()$;

$\}$

$\}$

$//$ Equality check

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

$\{$

using namespace std::rel$\_$ops;

if $($degree $!=$ p$.$degree$)$

return false;

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

if $($coefficients$[$i$]!=$ p$.$coefficients$[$i$])$

return false;

return true;

$\}$