Need help resizing dynamic array - Heap corruption detected - c++

Question

I am working on an assignment for my c++ class and am having trouble with one portion of the class that requires resizing a dynamic array. For this assignment, I need to store terms of a polynomial in a dynamic array. I am specifically having trouble with the setCoefficient function of my code, where I need to resize a dynamic array if I am trying to at a term to my polynomial that is larger than what the array can currently hold.
I tried following some other stack overflow posts on how to resize a dynamic array, but keep running into errors. Currently, I am running into an error of HEAP CORRUPTION DETECTED when I try and delete the old dynamic array in the setCoefficient function.
I have commented the setCoefficient function and was hoping someone could go through and help me determine where I am going wrong. Unfortunately, I am not allowed to use the STL vector class for this assignment.
Here is my .cpp file where you can see the implementation of the setCoefficient function that I am having trouble with:
#include "poly.h"
//Default constructor. Initializes a Poly to: 0x^0
Poly::Poly()
{
cout << "No parameter constructor called" << endl;
polyArray = new int[1];
//polyArray[1] = 0;
polyArray[0] = 0;
length = 0;
}
//Constructor with one argument. Initialized to: coefficientx^0
Poly::Poly(int coefficient)
{
cout << "One parameter constructor called" << endl;
cout << "coefficient: " << coefficient << endl;
polyArray = new int[1];
//polyArray[1] = 0;
polyArray[0] = coefficient;
length = 0;
}
//Constructor with two arguments. Initialized to: coefficientx^power
Poly::Poly(int coefficient, int power)
{
cout << "Two parameter constructor called" << endl;
cout << "power: " << power << endl;
cout << "coeff: " << coefficient << endl;
polyArray = new int[power]; //I think I need to add 1 here to account for that fact that arrays start at index 0.
for (int i = 0; i < power; i++) { //I want to initialize the dynamic array to all 0's
polyArray[i] = 0;
}
polyArray[power] = coefficient;
length = power;
}
//Destructor
Poly::~Poly()
{
cout << "I am the destructor" << endl;
polyArray = NULL;
delete [] polyArray;
}
//Copy constructor. Creates a deep copy of a Poly.
Poly::Poly(const Poly& p)
{
cout << "Copy constructor" << endl;
this->length = p.length;
cout << "this->length: " << this->length << endl;
cout << "p.length: " << p.length << endl;
this->polyArray = new int[this->length];
//Loop throguh the initial Poly and assign all values in the array to the new Poly.
for (int i = 0; i<=p.length; i++) {
this->polyArray[i] = p.polyArray[i];
cout << "this polyArray: " << this->polyArray[i] << endl;
cout << "p.polyArray: " << p.polyArray[i] << endl;
}
}
void Poly::setCoefficient(const int coefficient, const int power) {
if (power > this->length) {
//we need to resize the array we currently have.
//Here I am creating a new array that will temporarily store larger values
int* resizedArray = new int[power * 2];
//This for loop assigns all the values in the current object's array to the new array (resizedArray)
for (int i = 0; i < this->length; i++) {
resizedArray[i] = this->polyArray[i];
}
//Here I am adding the term that we wanted to add in the first place with setCoefficient
resizedArray[power] = coefficient;
//Deleting the terms in polyArray
delete [] this->polyArray;
//Creating a new array that has been resized
this->polyArray = new int[power * 2];
//Setting the values of the temporary array, resizedArray, to the array of the current object.
this->polyArray = resizedArray;
//modifying the length of the current object.
this->length = power * 2;
}
else {
this->polyArray[power] = coefficient;
}
}
and for completeness, here is my .h file as well (although I dont think the issue is in my .h:
// ------------------------------------------------ Poly.h ----------------------------------------------
#ifndef Poly_H
#define Poly_H
#include <iostream>
#include <string>
using namespace std;
class Poly {
friend ostream& operator<<(ostream& out, const Poly& p);
friend istream& operator>>(istream& in, Poly& p);
public:
//Member functions
Poly(); //Default constructor. Initializes a Poly to: 0x^0
Poly(int coefficient); //Constructor with one argument. Initialized to: coefficientx^0
Poly(int coefficient, int power); //Constructor with two arguments. Initialized to: coefficientx^power
Poly(const Poly& p); //Copy constructor. Creates a deep copy of a Poly.
~Poly(); //Destructor
int degree() const; //Returns the largest degree term in a Poly.
double getCoefficient(const int power) const; //returns the coefficient of the x^power term.
//Poly setCoefficient(const int coefficient, const int power); //Sets the coefficient of the term indicated by the power.
void setCoefficient(const int coefficient, const int power);
// Arithmetic operators
Poly operator+(const Poly& p) const;
Poly operator-(const Poly& p) const;
// Boolean comparison operators
bool operator==(const Poly& p) const;
bool operator!=(const Poly& p) const;
// Assignment operators
Poly& operator=(const Poly& p);
Poly& operator+=(const Poly& p);
Poly& operator-=(const Poly& p);
Poly& operator*=(const Poly& p);
//Clean up/delete all Poly terms.
void clear();
//Checks if the Poly is empty or not.
bool isEmpty() const;
private:
int length; //# of terms in the Poly/size of the array
int* polyArray;
};
#endif

Answer 1

One error is here (cout statements removed for brevity):
this->length = p.length;
this->polyArray = new int[this->length];
for (int i = 0; i<=p.length; i++) {
this->polyArray[i] = p.polyArray[i];
}
The test in your for-loop should be i<p.length rather than i<=p.length. Otherwise you are writing one value past the end of polyArray, which invokes undefined behavior (which can result and often does in a crash)