Memory Leak/Corruption of Heap

[mlholder]

Hi all,

I am trying to do some review of some C++ topics that I feel I need a refresher on. The problem that I am having is that one of the class objects is being deleted before it should be, or at least I think that is the problem. I am using Microsoft Visual C++ 2010 Express. Each run of the program always goes to the following code. Can anyone point me in the right direction as to what is causing this? Any help is greatly appreciated.

pUserData 0x00804d98 const void *
extern "C" _CRTIMP int __cdecl _CrtIsValidHeapPointer(
const void * pUserData
)
{
if (!pUserData)
return FALSE;

if (!_CrtIsValidPointer(pHdr(pUserData), sizeof(_CrtMemBlockHeader), FALSE))
return FALSE;

return HeapValidate( _crtheap, 0, pHdr(pUserData) );
}

#include <iostream>
#include <string>
#include <cstdlib>
#include <cmath>

using namespace std;

class Polynomial
{
	public:
		Polynomial();
		Polynomial(const Polynomial &);
		Polynomial(const double [], const int);
		~Polynomial();
		int getDegree() const;
		friend double evaluate(const Polynomial, double);
		friend void extractCoefficients(double* &, int &);
		friend void assignCoefficients(double*, int, Polynomial &);
		void operator =(const Polynomial &);
		friend Polynomial operator +(const Polynomial &, const Polynomial &);
		friend Polynomial operator -(const Polynomial &, const Polynomial &);
		friend Polynomial operator *(const Polynomial &, const Polynomial &);
		friend ostream& operator <<(ostream &, const Polynomial &);
	private:
		double *coefficients;
		int degree;
};

Polynomial::Polynomial() : degree(0)
{
	coefficients = new double[degree + 1];
	coefficients[0] = 0;
}
Polynomial::Polynomial(const Polynomial &poly) : degree(poly.getDegree())
{
	coefficients = new double[degree + 1];

	for(int index = 0; index < (degree + 1); index++)
		coefficients[index] = poly.coefficients[index];
}
Polynomial::Polynomial(const double coefs[], const int deg) : degree(deg)
{
	if(degree < 0)
	{
		char ch;
		cout << "Error: Illegal value for degree. Aborting program.\n";
		cin.get(ch);
		exit(1);
	}

	coefficients = new double[degree + 1];

	for(int index = 0; index < (degree + 1); index++)
		coefficients[index] = coefs[index];
}

Polynomial::~Polynomial()
{
	delete [] coefficients;
}

int Polynomial::getDegree() const
{
	return (degree);
}
double evaluate(const Polynomial poly, double num)
{
	double sum = 0;

	for(int index = 0; index < (poly.getDegree() + 1); index++)
		sum += (poly.coefficients[index] * pow(num, index));

	return sum;
}

void extractCoefficients(double* &coefs, int &deg)
{
	char ch;

	cout << "Enter the degree of the expression: ";
	cin >> deg;
	cout << endl;
	
	do
	{
		cin.get(ch);
	}while(ch != '\n');

	coefs = new double[deg + 1];

	cout << "Enter the coefficients of the expression. Enter 0 for a missing term.\n";
	for(int index = deg; index >= 0; index--)
		cin >> coefs[index];
	cout << endl;

	do
	{
		cin.get(ch);
	}while(ch != '\n');
}
void assignCoefficients(double *coefs, int deg, Polynomial &poly)
{
	poly.degree = deg;
	poly.coefficients = new double[poly.degree + 1];

	for(int index = 0; index < (deg + 1); index++)
		poly.coefficients[index] = coefs[index];
}

void Polynomial::operator =(const Polynomial &poly)
{
	degree = poly.getDegree();

	for(int index = 0; index < (degree + 1); index++)
		coefficients[index] = poly.coefficients[index];
}
Polynomial operator +(const Polynomial &lhs, const Polynomial &rhs)
{
	Polynomial temp;

	if(lhs.getDegree() > rhs.getDegree())
		temp.degree = lhs.getDegree();
	else
		temp.degree = rhs.getDegree();

	temp.coefficients = new double[temp.degree + 1];

	for(int index = 0; index < (temp.getDegree() + 1); index++)
	{
		if(index == lhs.getDegree())
		{
			temp.coefficients[index] = lhs.coefficients[index] + rhs.coefficients[index];
			index++;

			while(index <= rhs.getDegree())
			{
				temp.coefficients[index] = rhs.coefficients[index];
				index++;
			}
		}
		else if(index == rhs.getDegree())
		{
			temp.coefficients[index] = lhs.coefficients[index] + rhs.coefficients[index];
			index++;

			while(index <= lhs.getDegree())
			{
				temp.coefficients[index] = lhs.coefficients[index];
				index++;
			}
		}
		else
		{
			temp.coefficients[index] = lhs.coefficients[index] + rhs.coefficients[index];
		}
	}

	return temp;
}
Polynomial operator -(const Polynomial &lhs, const Polynomial &rhs)
{
	Polynomial temp;

	if(lhs.getDegree() > rhs.getDegree())
		temp.degree = lhs.getDegree();
	else
		temp.degree = rhs.getDegree();

	temp.coefficients = new double[temp.degree + 1];

	for(int index = 0; index < (temp.getDegree() + 1); index++)
	{
		if(index == lhs.getDegree())
		{
			temp.coefficients[index] = lhs.coefficients[index] - rhs.coefficients[index];
			index++;

			while(index <= rhs.getDegree())
			{
				temp.coefficients[index] = rhs.coefficients[index];
				index++;
			}
		}
		else if(index == rhs.getDegree())
		{
			temp.coefficients[index] = lhs.coefficients[index] - rhs.coefficients[index];
			index++;

			while(index <= lhs.getDegree())
			{
				temp.coefficients[index] = lhs.coefficients[index];
				index++;
			}
		}
		else
		{
			temp.coefficients[index] = lhs.coefficients[index] - rhs.coefficients[index];
		}
	}

	return temp;
}
Polynomial operator *(const Polynomial &lhs, const Polynomial &rhs)
{
	Polynomial temp;

	temp.degree = lhs.getDegree() + rhs.getDegree();
	temp.coefficients = new double[temp.degree + 1];

	for(int index = 0; index < (temp.degree + 1); index++)
		temp.coefficients[index] = 0;

	for(int i = 0; i < (lhs.getDegree() + 1); i++)
	{
		for(int j = 0; j < (rhs.getDegree() + 1); j++)
			temp.coefficients[i + j] += lhs.coefficients[i] * rhs.coefficients[j];
	}

	return temp;
}
ostream& operator <<(ostream &ostr, const Polynomial &poly)
{
	ostr << poly.coefficients[poly.getDegree()];

	if(poly.getDegree() > 1)
		ostr << "x^" << poly.getDegree();
	else if(poly.getDegree() == 1)
		ostr << "x";

	for(int index = poly.getDegree() - 1; index >= 0; index--)
	{
		if(index == 0)
		{
			if(poly.coefficients[index] < 0)
				ostr << " - " << fabs(poly.coefficients[index]);
			else if(poly.coefficients[index] > 0)
				ostr << " + " << poly.coefficients[index];
		}
		else if(index == 1)
		{
			if(poly.coefficients[index] < -1)
				ostr << " - " << fabs(poly.coefficients[index]) << "x";
			else if(poly.coefficients[index] == -1)
				ostr << " - x";
			else if(poly.coefficients[index] == 1)
				ostr << " + x";
			else if(poly.coefficients[index] > 1)
				ostr << " + " << poly.coefficients[index] << "x";
		}
		else
		{
			if(poly.coefficients[index] < -1)
				ostr << " - " << fabs(poly.coefficients[index]) << "x^" << index;
			else if(poly.coefficients[index] == -1)
				ostr << " - x^" << index;
			else if(poly.coefficients[index] == 1)
				ostr << " + x^" << index;
			else if(poly.coefficients[index] > 1)
				ostr << " + " << poly.coefficients[index] << "x^" << index;
		}
	}

	return ostr;
}

bool finished();

int main()
{
	//int lhsDeg(1), rhsDeg(1), deg;
	//double lhsCoefs[] = { -4, 3 }, rhsCoefs[] = { 2, 6 };

	int deg;
	double *coefs;

	Polynomial p1, p2, p3;

	do
	{
		system("cls");
		extractCoefficients(coefs, deg);
		assignCoefficients(coefs, deg, p1);

		extractCoefficients(coefs, deg);
		assignCoefficients(coefs, deg, p2);

		cout << "Addition\n";
		p3 = p1 + p2;
		cout << p3 << endl;
		cout << "Evaluation: " << evaluate(p3, 5) << endl << endl;

		cout << "Subtraction\n";
		p3 = p1 - p2;
		cout << p3 << endl;
		cout << "Evaluation: " << evaluate(p3, 5) << endl << endl;

		cout << "Multiplication\n";
		p3 = p1 * p2;
		cout << p3 << endl;
		cout << "Evaluation: " << evaluate(p3, 5) << endl << endl;

	}while(!finished());

	return 0;
}

bool finished()
{
	string str;

	do
	{
		cout << "Would you like to repeat the program? (Y/N): ";
		getline(cin, str);

		if( (str.find_first_not_of("YyNn") != string::npos) || (str.length() > 1) )
			cout << "Response entered is not valid.\n";

	}while( (str.find_first_not_of("YyNn") != string::npos) || (str.length() > 1) );

	cout << endl;

	if(str.find_first_of("Yy") != string::npos)
		return false;

	return true;
}

[ne555]

> The problem that I am having is that one of the class objects is being deleted before it should be,
> or at least I think that is the problem.
¿what makes you think that?

Running your problem through valgrind

==31312== Invalid write of size 8
==31312==    at 0x4013E3: Polynomial::operator=(Polynomial const&) (foo.cpp:115)
==31312==    by 0x4020EA: main (foo.cpp:288)
==31312==  Address 0x5a85d28 is 0 bytes after a block of size 8 alloc'd
==31312==    at 0x4C2AC10: operator new[](unsigned long) (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==31312==    by 0x400F6A: Polynomial::Polynomial() (foo.cpp:31)
==31312==    by 0x402048: main (foo.cpp:276)

The code that refers to

void Polynomial::operator =(const Polynomial &poly)
{
	degree = poly.getDegree(); //changed the `size' of the array, but do not reallocate

	for(int index = 0; index < (degree + 1); index++)
		coefficients[index] = poly.coefficients[index]; //out of bounds
}

When you do Polynomial p3; you reserve enough space just for one coefficient. Then in the assignment you simplly write to memory that you don't own.


Also, {assign,extract}Coeficients() are leaking memory as you simply do coefs = new double[degree+1]; but you didn't deallocate the previous memory.

[mlholder]

Thank you for your help ne555. I added

coefficients = new double[degree + 1];

to my overloaded assignment function and it fixed the problem. But my question now is, what is the difference between my assignment function and copy constructor, since they both have the same code? Thank you again for your help.

[ne555]

> But my question now is, what is the difference between my assignment function and copy constructor,
> since they both have the same code?
your assignment operator leaks memory and breaks with self-assignment.

http://stackoverflow.com/questions/3279543/what-is-the-copy-and-swap-idiom