What causes an initialized class member variable to become (or appear) uninitialized within a method call?

Question

I'm working on a programming lab on hash tables. The code we were given handles collisions by rehashing the key (by adding one) and trying again, simple, but works for lab. The problem is that, with the raw code, it could enter an infinite loop if you add a member to a full table. We were tasked to keep this from happening. I'm using a count for contents (contentCount) so it wont get caught up in a loop, i.e. if count >= size, it won't insert. The header and source files are below.

hashTable.h

#pragma once
#include <iostream>


using namespace std;

const int NONE = 0;
const int EMPTY = -1;
const int DELETED = -2;

class HashTable
{
public:
   // Constructors
   HashTable(int size);
   HashTable(const HashTable & ht);
   ~HashTable();

   // Methods
   bool Insert(int key, int value);
   bool Search(int key, int &value);
   bool Delete(int key);
   void Print();

private:
   // Private methods
   int Hash(int key);
   int Hash2(int index);

   // Private data
   int Size;
   int *Value;
   int *Key;
   int contentCount;
};

hashTable.cpp

#include "hashTable.h"


HashTable::HashTable(int size)
{
   Size = size;
   Value = new int[Size];
   Key = new int[Size];

   for (int index=0; index < Size; index++)
   {
      Value[index] = NONE;
      Key[index] = EMPTY;
   }
}


HashTable::HashTable(const HashTable & ht)
{
    contentCount = 0;
   Size = ht.Size;
   Value = new int[Size];
   Key = new int[Size];

   for (int index=0; index < Size; index++)
   {
      Value[index] = ht.Value[index];
      Key[index] = ht.Key[index];
   }
}


HashTable::~HashTable()
{
   delete []Value;
   delete []Key;
}


bool HashTable::Insert(int key, int value)
{
    if(contentCount >= Size)
    {
        return false;
    }
   // Find desired key
   int index = Hash(key);
   while ((Key[index] != key) && (Key[index] != EMPTY))
      index = Hash2(index); 

   // Insert value into hash table
   Value[index] = value;
   Key[index] = key;
   contentCount++;
   return true;
}


bool HashTable::Search(int key, int &value)
{
   // Find desired key
   int index = Hash(key);
   while ((Key[index] != key) && (Key[index] != EMPTY))
      index = Hash2(index); 

   // Return value from hash table
   if (Key[index] == key)
      value = Value[index];
   return (Key[index] == key);
}


bool HashTable::Delete(int key)
{
   // Find desired key
   int index = Hash(key);
   while ((Key[index] != key) && (Key[index] != EMPTY))
      index = Hash2(index); 

   // Delete value from hash table
   if (Key[index] == key)
   {
      Value[index] = NONE;
      Key[index] = DELETED;
      contentCount--;
      return true;
   }
   return false;
}


int HashTable::Hash(int key)
{
   return key % Size;
}


int HashTable::Hash2(int index)
{
    cout << "COLLISION\n";
   return (index+1) % Size;
}


void HashTable::Print()
{
   cout << "Index\t" << "Value\t" << "Key\n";
   for (int index=0; index < Size; index++)
      cout << index << "\t"
           << Value[index] << "\t" 
           << Key[index] << "\n";
}

Thanks ahead for the help!

Answer 1

You're initializing contentCount in the copy constructor, but in HashTable(int size), you're not.

So obviously, it will be uninitialized.