C++ Memory leakage with Dynamic Arrays - c++

Question

I had to build a dynamic array class from scratch myself, and I also tried to extend it with a (set like) function to add new elements into the array, it compiles well, but the program crashes, since it has some memory leakages.
Please try and help me, I'm on a short notice at school.
The array class
template <class T>
class Array
{
int n; /// size
T* data;
public:
explicit Array(int n): n(n) { adat=new T[n]; }
Array(const Array&);
Array& operator=(const Array&);
~Array();
T& operator[](int idx) { return data[idx]; }
int size() { return n; }
int lookfor(T);
void add(T);
void del();
};
DEFINITIONS
template <class T>
Array<T>::Array(const Array<T>& t)
{
n=t.n;
data=new T[n];
for (int idx=0; idx<n; ++idx)
data[idx]=t.data[idx];
}
/**
Operator=
*/
template <class T>
Array<T>& Array<T>::operator=(const Array<T>& t)
{
if (this==&t) return *this;
delete[] data;
n=t.n;
data=new T[n];
for (int idx = 0; idx < n; ++idx)
data[idx]=t.data[idx];
return *this;
}
/**
dtor
*/
template <class T>
Array<T>::~Array()
{
del();
}
This must be the wrong part
template <class T>
int Array<T>::lookfor(T el)
{
for(int idx = 0; idx < n; ++idx)
if(data[idx] == el)
return idx;
return -1;
}
/**
add
*/
template <class T>
void Array<T>::add(T el)
{
if(lookfor(elem) != -1)
{
T* temp = new T[n + 1];
for (int idx = 0; idx < n; ++idx)
temp[idx]=data[idx];
temp[n + 1] = el;
del();
data = temp;
++n;
}
}
template <class T>
void Array<T>::del()
{
for(int idx = 0; idx < n; ++idx)
delete data[idx];
delete[] data;
}
The code it fails with:
Control ctrl;
ctrl.add(new Room());
ctrl.add(new Room());
Control and Room are both subclasses of the array. Like Control : publicArray < Room* >

Answer 1

Get rid of the loop in del() that deletes all the data[idx] elements. data is not an array of pointers, it's an array of values of type T, so you can't delete them. Even if you make an array of pointers, these pointers came from the caller to add, and they're owned by that part of the program, not the Array class. You also don't want to delete all the old pointers when you add an element to the array, because the new data array still contains those pointers.
Calling delete on something that wasn't created using new results in undefined behavior, which is likely causing your crash.