copy constructor & op= for my HashTable

[jls36]

I made a adjustable HashTable with an array of STL list(s). I can get every thing to work except the copy constructor and the operator=. It will compile it eerrors out during run time

If anyone can help me or give me some tips I would be greatful.

Thanks for your time in advance.

DynamList.h

#include <algorithm>
#include <assert.h> 
#include <list>

#ifndef DynamList_h
#define DynamList_h


#define HASHTABLE_CAPACITY 1009

template <class DataType>
class DynamList
{
public:
  DynamList();
  DynamList(const list<DataType>*);
  ~DynamList();
  list<DataType>* operator=(const list<DataType>*);
  void insert(const DataType&);
  bool first(DataType& getData);
  bool getNext(DataType&);
  bool retrieve(DataType&);
  bool remove(DataType&);
  bool replace(DataType&);
  int getSize() const; // getter
  double getLoadFactor() const; // getter

private:
  list<DataType>* aList; 
  typename list<DataType>::iterator it;
  typename list<DataType>::const_iterator itRe; // const_ for retrieve only!
  void reSize();
  bool isPrime(int);
  void setWrappedIndex(int); // setter
  int wrappedIndex;
  int size, current;
  int capacity;

};
template <class DataType>
DynamList<DataType>::DynamList()
: size(0), wrappedIndex(0), current(-1), capacity(HASHTABLE_CAPACITY), aList(new list<DataType>[HASHTABLE_CAPACITY])
{ }

// copy constructor, need to fix
template <class DataType>
DynamList<DataType>::DynamList(const list<DataType>* a)
: size(a.size), current(a.current), capacity(a.capacity)
{
  list<DataType>* newList = new list<DataType>[capacity];

  DataType data;

  first(data);

      do
      { 
       
        setWrappedIndex(data.hashCode());
        newList[wrappedIndex].push_back(data); 
       

      }while(getNext(data));

    // delete array  
    delete [] aList;
    
  aList = newList; // put elements back into the re-sized array   
  current = wrappedIndex;

  /*
 // aList = a.aList;
 
  aList = 0;

  //if(capacity > 0)
    aList = new list<DataType>[capacity];

  for (int i = 0; i < capacity; i++)
    aList[i] = a.aList[i];
    */
}

// operator= need to fix
// This was the last stuff tried but way off from my original
/*
template <class DataType>
list<DataType>* DynamList<DataType>::operator=(const list<DataType>* a)
{


  
  if (this != &a) // if true
  {
    size = a.size; // set length
    current = a.current; // set current
    capacity = a.capacity;
    
    
    list<DataType>* newList = new list<DataType>[capacity]


  
 // } // close if

  //return *this; // return *this

}*/

template <class DataType>
DynamList<DataType>::~DynamList()
{

  delete [] aList;

}

template <class DataType>
 void DynamList<DataType>::insert(const DataType& newData)
 {
  setWrappedIndex(newData.hashCode());
  
  it = find(aList[wrappedIndex].begin(), aList[wrappedIndex].end(), newData); 
  
  if (it != aList[wrappedIndex].end()) *it = newData; // replace 

  else 
  {
    aList[wrappedIndex].push_back(newData); 
    current = wrappedIndex;
    size++;

  } // close else

  if (getLoadFactor() > .8)
      reSize();
  
}

 template <class DataType>
void DynamList<DataType>::setWrappedIndex(int DI)
{
  if (DI > capacity)
  {
    wrappedIndex = DI % capacity;

    if (wrappedIndex > capacity)
    {
      while (wrappedIndex > capacity)
        wrappedIndex = wrappedIndex % capacity;

    } // close if

  } // close if

  else if (DI < 0)
  {
    while (DI < 0 && DI < capacity)
      DI += capacity;
   

    wrappedIndex = DI;

  } // close else-if

  else
    wrappedIndex = DI;

} // close setWrappedIndex

template <class DataType>
bool DynamList<DataType>::isPrime(int aNum)
{
  int max = static_cast <int> (aNum); /* Cast it to remove warnings */
        
  if (aNum <= 0 || aNum == 1 || (aNum % 2 == 0 && aNum != 2)) return false;
        
  for (int i = 3; i < max; i += 2)
    if (aNum % i == 0)
      return false;
      
  return true;

}

template <class DataType>
void DynamList<DataType>::reSize()
{
  int i = 0;

   while(!isPrime((capacity * 2) + i))
     i++;

  int newCapacity = (capacity * 2) + i;
  int oldCapacity = capacity;
  DataType data;

  list<DataType>* newList = new list<DataType>[newCapacity];
  
      first(data);

      do
      { 
        capacity = newCapacity;
        setWrappedIndex(data.hashCode());
        newList[wrappedIndex].push_back(data); 
        capacity = oldCapacity;

      }while(getNext(data));

    // delete array  
    delete [] aList;
    
  aList = newList; // put elements back into the re-sized array
  capacity = newCapacity;   
  current = wrappedIndex;  

}

template <class DataType>
bool DynamList<DataType>::first(DataType& getData)
{
  assert(current >= -1 && current < capacity);

  for (current = 0; current < capacity; current++)
  {
    if (!aList[current].empty())
    {
      it = aList[current].begin();
      break;
    } 
  }

  if (current == capacity) current = -1;

  if (current == -1) return false;

  getData = *it;

  return true;
}


template <class DataType>
bool DynamList<DataType>::getNext(DataType& getData)
{
  assert(current >= -1 && current < capacity);

  if (current == -1) return false;

  assert(!aList[current].empty());

  getData = *it++;

  if (it == aList[current].end())
  {
    for (current = current + 1; current < capacity; current++)
    {
      if (!aList[current].empty())
      {
        it = aList[current].begin();
        break;
     
      } 
    } 
  }
  
  if (current == capacity) current = -1;
  
  return current >= 0;
}


template <class DataType>
double DynamList<DataType>::getLoadFactor() const
{
  return double(size) / capacity;

}


template <class DataType>
int DynamList<DataType>::getSize() const
{
  return size;

} // close get size 


template <class DataType>
bool DynamList<DataType>::retrieve(DataType& getData)
{
  setWrappedIndex(getData.hashCode());

  itRe = find(aList[wrappedIndex].begin(), aList[wrappedIndex].end(), getData); 

  if (itRe == aList[wrappedIndex].end()) return false; 
 
  getData = *itRe; 
  current = wrappedIndex;

  return true;

}

template <class DataType>
bool DynamList<DataType>::remove(DataType& data)
{
  setWrappedIndex(data.hashCode());

  it = find(aList[wrappedIndex].begin(), aList[wrappedIndex].end(), data); 

  if (it == aList[wrappedIndex].end()) return false; 
 
  aList[wrappedIndex].erase(it);  
  size--;
  current = wrappedIndex;

  return true;

} // close remove

template <class DataType>
bool DynamList<DataType>::replace(DataType& data)
{
  setWrappedIndex(data.hashCode());

  it = find(aList[wrappedIndex].begin(), aList[wrappedIndex].end(), data); 

  if (it == aList[wrappedIndex].end()) return false; 

  *it = data;
  current = wrappedIndex;

  return true;

}

#endif 

[IceThatJaw]

Ok, Im not gonna read through all that code but i will show you the conventions.

Examine this:

class Example { 
public:
	 Example() {
               z = NULL;   // set all pointers to NULL in every constructor!!!
        }
      
        Example(const Example& ex) {  
		z = NULL;		
		CopyIntoThis(ex);      
	}		

	Example& operator = (const Example& ex) {
		if (this != &ex)  
			CopyIntoThis(ex);
		
		return *this;
	}
	
	
private:
	CopyIntoThis(const Example& ex) {
		if (ex.z) {
	           delete z;
		   z = new int;
	           z = ex.z;
                }
	}

        int* z;
};
		

Edit- don't you want list<DataType>* newList = new list<DataType>[capacity];

to be

aList = new list<DataType>[capacity]; ? Why use a temp in a copy constructor? Just check properly.

I would set aList to NULL, then check if capacity is greater than 0 before I copy anything.

[andywestken]

Your copy constructor has the wrong parameter type to be a copy constructor. As IceThatJaw's example shows, the parameter type of a copy constructor is the same class as what which the method is being defined for. So I'de expect your class declaration to start off:

template <class DataType>
class DynamList
{
public:
  DynamList();
  DynamList(const DynamList&); // copy construtor
  ~DynamList();
  DynamList& operator=(const DynamList&); // assignent operator

  ...

It's ok to have a constuctor which takes a pointer to a list, but it's not a copy constructor.

And I'm uneasy about

list<DataType>* operator=(const list<DataType>*);

as you're setting a non-pointer type to equal a pointer type. If you need this functionality, I would consider using something along the lines of a setList(const list<DataType>*) method -- doing a copy -- or even attachList(list<DataType>*) -- which does what it says.

Andy

[jls36]

Thanks for all the tips and help I will try these and see if I can get things to work properly. I used the * instead of the & b/c I was thinking it was like passing a dynamic array to a function. I know normally the & is used but that didn't work for me so I was just trying anything I know which isn't a lot Im a advance beginner I guess you could say.

Thanks again for your time.