dynamic template array classs

[otisphat80]

Hello everyone I am working on a exercise for a class of mine. I have been looking at this for too long I need a fresh set of eyes. In my dynamic_template_array class the addEntry() function works fine if I add pass one entry to it. If I send more that one entry to it in a loop it does nothing wont print out anything. I have tried a multitude of things well you'll see.If someone could just let me know where I went wrong I would really appreciate it. Thanks.

#ifndef DYNAMICTEMPLATEARRAY_H
#define DYNAMICTEMPLATEARRAY_H

#include <string.h>

template<class T>
class DynamicTemplateArray
{

public:
	DynamicTemplateArray( );
	DynamicTemplateArray(int size);
	DynamicTemplateArray(const DynamicTemplateArray& other);
	~DynamicTemplateArray();
	DynamicTemplateArray& operator=(const DynamicTemplateArray& other);
	int findIndexToRemove(T& item2Remove);
	int getSize( ) const;
	void addEntry(const T& entry);
	bool deleteEntry(T entry2Remove);
	T& getEntry(int index) const;

private:
	int _size;
	T *_dynamicArray;

};

template<class T>
DynamicTemplateArray<T>::DynamicTemplateArray(		):
							_size(0),
							_dynamicArray(NULL)
{  }

template<class T>
DynamicTemplateArray<T>::DynamicTemplateArray(		int size):
							_size(size)
{ _dynamicArray = new T[_size]; }

template<class T>
DynamicTemplateArray<T>::DynamicTemplateArray(const DynamicTemplateArray<T> &other)  //<-------------TESTED
{
	this->_size = other._size;
	this->_dynamicArray = new T[_size];
	
	for(int i =0; i < _size; i++)
		this->_dynamicArray[i] = other._dynamicArray[i];
}

template<class T>
DynamicTemplateArray<T>::~DynamicTemplateArray()	//<-------- TESTED
{
	delete [] _dynamicArray;
}

template<class T>
DynamicTemplateArray<T>& DynamicTemplateArray<T>::operator=(const DynamicTemplateArray<T>& other)  //<-------- TESTED
{
	this->_size = other._size;
	this->_dynamicArray = new T[_size];
	memcpy(this->_dynamicArray, other._dynamicArray, sizeof(_dynamicArray));
	return this;
}

template<class T>
int DynamicTemplateArray<T>::getSize( ) const
{
	return _size;
}

template<class T>
void DynamicTemplateArray<T>::addEntry(const T& entry)  //<-------- WORKS WITH SINGLE ENTRY WONT WORK IN LOOP
{
	int newSize = _size +1;
	T* temp = new T[newSize];
	
//		for (int i = 0; i < _size; i++)
//		{
//			temp[i] = _dynamicArray[i]; 
//		}
//		
		memcpy(temp, _dynamicArray, sizeof(_dynamicArray));
		temp[_size] = entry;
                
//                 _dynamicArray = temp;                
//                temp = NULL;
                 
		std::swap(_dynamicArray, temp);
		_size++;
		delete [] temp;
		
}

template<class T>
bool DynamicTemplateArray<T>::deleteEntry(T entry2Remove)		//<-------- TESTED
{
	int index = findIndexToRemove(entry2Remove);
	
	if(index != -1)
	{
		T *temp = new T[_size-1];
			
		for (int i =0; i < index; i++)
		{
			temp[i] = _dynamicArray[i]; 
		}
		for (int i = index+1; i < _size; i++)
		{
			temp[i] = _dynamicArray[i]; 
		}
		std::swap(_dynamicArray, temp);
		_size--;
		delete [] temp;
		return true;
	}
	return false;
}

template<class T>
T& DynamicTemplateArray<T>::getEntry(int index) const	//<-------- TESTED
{
	return _dynamicArray[index];
}

template<class T>
int DynamicTemplateArray<T>::findIndexToRemove(T& entry2Remove)	//<-------- TESTED
{
	int index = -1;
	
	for (int i =0; i < _size; i++)
	{
		if (_dynamicArray[i] == entry2Remove)
		{
			index = i;
			break;
		}
	}
	return index;
}

#include <iostream>
#include "dynamic_template_array.h"



int main(int argc, char **argv)
{
	DynamicTemplateArray<int> intArray(5);
		
	//<------- START
	std::cout << "Array To Start" << std::endl;
	for(int i =0; i < intArray.getSize( ); i++)
		std::cout << intArray.getEntry(i) << std::endl;
	
	//<------- DELTING
	std::cout << "Deleting two elements...........\n" << std::endl;
	for(int i =0; i < intArray.getSize( ) -3 ; i++)
		intArray.deleteEntry(i);
	
	//<------- After DELETE
	std::cout << "Array After deleting" << std::endl;
	for(int i =0; i < intArray.getSize( ); i++)
		std::cout << intArray.getEntry(i) << std::endl;
	
	//<---------- ADDING
	std::cout << "Adding 2 elements................\n" << std::endl;
	for(int i =0; i < intArray.getSize( ); i++)
		intArray.addEntry(5);
	
	//<------- After ADD
	std::cout << "Array After Adding" << std::endl;
	for(int i =0; i < intArray.getSize( ); i++)
		std::cout << intArray.getEntry(i) << std::endl;

	return 0;
}

[abhishekm71]

for(int i =0; i < intArray.getSize( ); i++)
		intArray.addEntry(5);

don't give a constant as a paramter to the function addEntry. It takes the "T" parameter as reference.

[otisphat80]

Thanks, I solved it on my own dumb mistake sorry for wasting your time I just need to get and walk away some times.

[cire]

Just in case this turns up in a search and someone has a similar problem, the biggest issue was the use of sizeof on line 81. sizeof(pointer_type) yields the size of a pointer, and not size of the memory it points to.

Aside from that, one should never use memcpy in template code which is not restricted to trivial types. Instead, prefer std::copy:

#include <algorithm>

template<class T>
void DynamicTemplateArray<T>::addEntry(const T& entry)
{
    int newSize = _size +1;
    T* temp = new T[newSize];
	
    std::copy(_dynamicArray, _dynamicArray+_size, temp) ;
    temp[_size++] = entry;
                
    delete [] dynamicArray ;
    dynamicArray = temp ;
}

[otisphat80]

Thank you cire.