Reputation: 1195
This class is for a midterm assignment. It's a dynamic array that works like a vector. The problem is that when a new index is added to the array then the destructor is called(when the program ends) the program throws an exception and takes to a file called dgbheap.c. it happens when I delete origin only in the destructor.
DynamicArray.h
#ifndef DYNAMICARRAY_H
#define DYNAMICARRAY_H
#include <new>
#include <cstdlib>
using namespace std;
template <class T>
class DynamicArray
{
private:
T *origin;
T *allocator;
int size;
int current;
public:
DynamicArray();
DynamicArray(int);
DynamicArray(const DynamicArray&);
~DynamicArray();
void add(int);
void empty();
void remove(int);
int getSize();
T &operator[](const int&);
const T operator=(const DynamicArray&);
void put(T&);
void put(T);
};
template <class T>
DynamicArray<T>::DynamicArray()
{
origin = new T[5];
allocator = NULL;
size = 5;
current = 0;
}
template <class T>
DynamicArray<T>::DynamicArray(int s)
{
size = s;
try
{
origin = new T[s];
allocator = NULL;
current = 0;
}
catch(bad_alloc)
{
cout << "Error: Bad memery allocation\n";
exit(EXIT_FAILURE);
}
}
template <class T>
DynamicArray<T>::DynamicArray(const DynamicArray& obj)
{
empty();
for(int counter = 0; counter < obj.size - 1; counter++)
{
origin[counter] = obj.origin[counter];
}
}
template <class T>
DynamicArray<T>::~DynamicArray()
{
delete [] origin;
delete [] allocator;
}
template <class T>
void DynamicArray<T>::add(int size)
{
allocator = new T[size];
for(int counter = 0; counter < this-> size - 1; counter++)
{
allocator[counter] = origin[counter];
}
delete [] origin;
origin = new T[size];
this->size = this->size + size;
for(int counter = 0; counter < this->size - 1; counter++)
{
origin[counter] = allocator[counter];
}
allocator = NULL;
}
template <class T>
void DynamicArray<T>::empty()
{
if(size >= 0)
delete [] origin;
}
template <class T>
int DynamicArray<T>::getSize()
{
return size;
}
template <class T>
T &DynamicArray<T>::operator[](const int &index)
{
return origin[index];
}
template <class T>
const T DynamicArray<T>::operator=(const DynamicArray &obj)
{
size = obj.size;
delete [] origin;
origin = new T[size];
for(int counter = 0; counter < size; counter++)
*(origin + counter) = *(obj.origin + counter);
return *origin;
}
template <class T>
void DynamicArray<T>::put(T &obj)
{
if(current == size - 1)
{
add(1);
origin[size - 1] = obj;
++current;
}
else
{
origin[current] = obj;
++current;
}
}
template <class T>
void DynamicArray<T>::put(T obj)
{
if(current > size - 1)
{
add(1);
origin[size - 1] = obj;
++current;
}
else
{
origin[current] = obj;
++current;
}
}
template <class T>
void DynamicArray<T>::remove(int location)
{
allocator = new T[size - 1];
int skipper = 0;
for(int counter = 0; counter < size - 1; counter++, skipper++)
{
if(counter != location)
allocator[counter] = origin[skipper]
else if(counter == location)
{
++skipper;
allocator[counter] = origin[skipper]
continue;
}
}
}
#endif // !DYNAMICARRAY_H
main.cpp
#include <iostream>
#include <string>
#include "DynamicArray.h"
using namespace std;
int main()
{
DynamicArray<int> a(5);
a.put(21);
a.put(22);
a.put(30);
a.put(58);
a.put(87);
a.put(87);
cout << a[0] << endl;
cout << a[1] << endl;
cout << a[2] << endl;
cout << a.getSize() << endl;
system("pause");
return 0;
}
Upvotes: 1
Views: 1145
Reputation: 7132
The problem is in:
template void DynamicArray::add(int size);
You're confusing your size variables that have same name this->size and argument size
Here's the corrected member function:
template <class T>
void DynamicArray<T>::add(int size)
{
allocator = new T[this->size]; // was just 'size', needs to be old size
for(int counter = 0; counter < this->size - 1; counter++)
{
allocator[counter] = origin[counter];
}
delete [] origin;
this->size = this->size + size; // was down one line
origin = new T[this->size]; // was 'size'. ie old size, not new size set in line above
for(int counter = 0; counter < this->size - 1; counter++)
{
origin[counter] = allocator[counter];
}
allocator = NULL;
}
Upvotes: 1
Reputation: 64308
Your copy constructor isn't initializing origin
. It should be something like this:
template <class T>
DynamicArray<T>::DynamicArray(const DynamicArray& obj)
: origin(new T[obj.size]),
size(obj.size),
allocator(NULL),
current(obj.current)
{
for(int counter = 0; counter < obj.size; counter++)
{
origin[counter] = obj.origin[counter];
}
}
Also be careful with your empty()
method:
template <class T>
void DynamicArray<T>::empty()
{
delete [] origin;
origin = NULL;
size = 0;
}
Upvotes: 1