Thread: Class/Pointer Question

I am making my first (semi-)usefull application: my own vector class :P I'm having some troubles with pointers: when I delete them in the destructor, I get a memory leak when I run the program (Something like: "glibc detected blabal double free or corruption" and then a lot of memory addresses) If I don't delete the pointers in the destructor, everything runs fine. I am sure I don't delete somewhere else.
Here's the class declaration:

Code:

template <class T>
class myVec
{
	T *arrPtr;
	T *temp;
	int count;
public:
	myVec(int numElements);
	myVec();
	~myVec();

	void addOnTop(T value);
	void addBegin(T value);
	void erase(int index);
	int size() { return count; }
	bool isEmpty();

	T& operator=(const myVec &a);
	T& operator[](int index) {if(index > (count-1)) { cout << "Memory overload!!"; } else { return arrPtr[index]; } }
};

And then I have a second question: if you have a class, you can declerate some variables outside public/private/protected. What I know you can't access the variables by myObj.value, but is it protected, private or something else?

Class variables are private by default. This, by the way, is the only real difference between the class keyword and struct keyword (which is public, by default) in C++.

... and you'll need to provide more code for me to see why deleting in the destructor causes leaks.

@ Kurt: I'm not finished yet!
@ Sly:Nevermind, I found the mistake, I deleted in my Constructor :P Why Static?

Try:

Code:

delete[] arrPtr;
delete[] temp;

Also, those lines work better in your destructor, not your default constructor.

I finished my Vector class... I think.

Code:

#include <iostream>

using namespace std;

template <class T>
class myVec
{
	T *arrPtr;
	T *temp;
	int count;
public:
	myVec(int numElements);
	myVec();
	~myVec();

	void addOnTop(T value);
	void addBegin(T value);
	void erase(int index);
	void erase(int begin, int end);
	int size() { return count; }
	bool isEmpty();
	void assign(int num, T value);
	void resize(int num);
	void clear();
	void insert(int pos, T value);

	T& operator=(const myVec &a);
	T& operator[](int index) {if(index > (count-1)) { cout << "Memory overload!!"; } else { return arrPtr[index]; } }
};

template <class T>
myVec<T>::myVec(int numElements)
{
	count = numElements;
	arrPtr = new T[count];
	temp = new T[count];
}

template <class T>
myVec<T>::myVec()
{
	count = 0;
	arrPtr = new T[count];
	temp = new T[count];
}

template <class T>
myVec<T>::~myVec()
{
	delete arrPtr;
	delete temp;
}

template <class T>
void myVec<T>::addOnTop(T value)
{
	temp = new T[count];
	for(int i = 0; i < count; i++)
	{
		temp[i] = arrPtr[i];
	}
	count++;
	arrPtr = new T[count];
	for(int i = 0; i < count; i++)
	{
		arrPtr[i] = temp[i];
	}
	arrPtr[count-1] = value;
}

template <class T>
void myVec<T>::addBegin(T value)
{
	temp = new T[count];
	for(int i = 0; i < count; i++)
	{
		temp[i] = arrPtr[i];
	}
	count++;
	arrPtr = new T[count];
	arrPtr[0] = value;
	for(int i = 0; i < count; i++)
	{
		arrPtr[i+1] = temp[i];
	}
}

template <class T>
void myVec<T>::erase(int index)
{
	temp = new T[count-1];
	for(int i = 0; i < index; i++)
	{
		temp[i] = arrPtr[i];
	}
	for(int i = (index+1); i < count; i++)
	{
		temp[i-1] = arrPtr[i];
	}
	count--;
	arrPtr = new T[count];
	for(int i = 0; i < count; i++)
	{
		arrPtr[i] = temp[i];
	}
}

template <class T>
void myVec<T>::erase(int begin, int end)
{
	int minus = end-begin;
	temp = NULL;
	temp = new T[count-minus];
	for(int i = 0; i < begin; i++)
	{
		temp[i] = arrPtr[i];
	}
	for(int i = end; i < count; i++)
	{
		temp[i-minus] = arrPtr[i];
	}
	arrPtr = NULL;
	count -= minus;
	arrPtr = new T[count];
	for(int i = 0; i < count; i++)
	{
		arrPtr[i] = temp[i];
	}
}

template <class T>
bool myVec<T>::isEmpty()
{
	if(count == 0)
	{
		return true;
	}
	else
	{
		return false;
	}
}

template <class T>
T& myVec<T>::operator=(const myVec &a)
{
	count = a.count;
	arrPtr = new T[count];
	for(int i = 0; i < count; i++)
	{
		arrPtr[i] = a.arrPtr[i];
	}
}

template <class T>
void myVec<T>::resize(int num)
{
	count = num;
	arrPtr = new T[count];
	for(int i = 0; i < count; i++)
	{
		arrPtr[i] = 0;
	}
}

template <class T>
void myVec<T>::assign(int num, T value)
{
	count = num;
	arrPtr = new T[count];
	for(int i = 0; i < count; i++)
	{
		arrPtr[i] = value;
	}
}

template <class T>
void myVec<T>::clear()
{
	count = 0;
	arrPtr = new T[0];
}

template <class T>
void myVec<T>::insert(int pos, T value)
{
	temp = new T[count+1];
	for(int i = 0; i < pos; i++)
	{
		temp[i] = arrPtr[i];
	}
	for(int i = (pos+1); i < count; i++)
	{
		temp[i-1] = arrPtr[i];
	}
	count++;
	arrPtr = new T[count];
	for(int i = 0; i < count; i++)
	{
		if(i == pos)
			arrPtr[i] = value;
		else
			arrPtr[i] = temp[i];
	}
}

What do you think of it?

The constructor that accepts an int argument should be declared explicit. If not, you could run into situations like:

Code:

myVec<int> vec = 10;

I fixed all the bugs you pointed out, I'll expand it with other vector-like functions.