7 replies to this topic

[Rambo]

Considering you paid $500 for the course, and this is detrimental to your grade I would ask to be paid more than $15 per assignment

[Rambo]

Even if I told you your signature is super pretty?

Even if you told me my signature is super pretty

(Oh, and I am gay so the nudes won't work for me )

[Scot]

Pm'd you~

[Melchoire]

Dynamic arrays? Well I this was my first assignment. It's a "list" object and you can keep adding new elements to it. Works with 0 memory leaks but I had to follow the proff's public interface so you may want to change it:

#include <iostream>
#include <string.h>

using namespace std;

template <class T> class list
{
	public:
		list();
		~list();
		int size();
		void add(const T item);
		T remove(const T item);
		T get(const T item);
		bool contains(const T item);
		void removeAll();
		void print();
	private:
		T* data;
		int list_size;
};

//constructor
template <class T>
list<T>::list()
{
	T* data = new T[0];
	list_size = 0;
}

//destructor
template <class T>
list<T>::~list()
{
	//can't call delete on an empty list otherwise it will be an invalid pointer
	if(list_size != 0)
		delete [] data;
}

//+size() returns int
template <class T>
int list<T>::size()
{
	return list_size;
}

//+print() returns void
template <class T>
void list<T>::print()
{
	for(int i = 0; i <= list_size - 1; i++)
	{
		cout << data[i] << endl;
	}
}

//+add(T: item) returns void
template <class T>
void list<T>::add(const T item)
{
	if(list_size == 0)
	{
		data = new T[1];
		data[0] = item;
		list_size++;
		return;
	}
	
	bool item_found = false;
	for(int i = 0; i <= list_size - 1; i++)
	{
		if(data[i] == item)
		{
			item_found = true;
			break;
		}
	}
	
	try
	{
		if(item_found)
		{
			throw(-1);
		}
	}
	catch(int)
	{
		cerr << "Failed to add " << item << ". Item has already been added" << endl;
		return;
	}
	
	
	T* temp = new T[list_size];
	
	memcpy(temp, data, sizeof(T)*list_size);
	
	delete [] data;
	data = new T[list_size + 1];
	
	memcpy(data, temp, sizeof(T)*list_size);
	data[list_size] = item;
	
	delete [] temp;
	
	list_size++;
}

//+remove(T: item) returns 
template <class T>
T list<T>::remove(const T item)
{
	try
	{
		if(list_size == 0)
		{
			throw(-1);
		}
	}
	catch(int)
	{	
		cerr << "Failed to remove item, list is empty!" << endl;
		return NULL;
	}
	
	bool item_found = false;
	int index;
	for(int i = 0; i <= list_size - 1; i++)
	{
		if(data[i] == item)
		{
			index = i;
			item_found = true;
			break;
		}
	}
	
	if(!item_found)
	{
		return NULL;
	}
	
	int size_b1 = index;
	int size_b2 = list_size - index - 1;
	int* b1 = new int[size_b1];
	int* b2 = new int[size_b2];
	
	memcpy(b1, data, sizeof(T)*size_b1);	
	memcpy(b2, data + index + 1, sizeof(T)*size_b2);
	
	delete [] data;
	data = new T[list_size - 1];
	
	memcpy(data, b1, sizeof(int)*size_b1);
	memcpy(data + size_b1, b2, sizeof(int)*size_b2);
	
	delete [] b1;
	delete [] b2;
	
	list_size--;
	
	return item;
}

//+get(T: item) returns T
template <class T>
T list<T>::get(const T item)
{
	try
	{
		if(list_size == 0)
		{
			throw(-1);
		}
	}
	catch(int)
	{	
		cerr << "Failed to retrieve item, list is empty!" << endl;
		return NULL;
	}
	
	
	for(int i = 0; i <= list_size - 1; i++)
	{
		if(data[i] == item)
		{
			return item;
		}
	}
	
	return NULL;
}

//+removeAll returns void
template <class T>
void list<T>::removeAll()
{
	if (list_size == 0)
	{
		return;
	}
	
	delete [] data;
	data = new T[0];
	list_size = 0;
}

template <class T>
bool list<T>::contains(const T item)
{
	if(list_size != 0)
	{
		for(int i = 0; i <= list_size - 1; i++)
		{
			if(data[i] == item)
			{
				return true;
			}
		}
		
		return false;
	}
}

I also have a linked list and a queue if you want to see those?