如何检查类数组的元素是否为空？ [c ++]

Question

For my latest assignment, I need to create a hash table that houses stocks, which are encapsulated in a class. To avoid collisions, I need to use linear probing. The problem I've run into, however; is that I can't test whether or not an element of the array (which is the hash table) is empty.

Here's some code aggregated from several files, but this is just to give you an idea of what's going on.

class Stock{

friend class HashMap

}

class HashMap{

bool get() //this function is used for putting new stocks into the table
private:
  struct Slot {
    Stock  slotStock;
  }
Slot *slots;
}

Within the get() function

while(slots[index] != NULL)

This gives an error: no operator "!=" matches these operands HashMap::Slot != int

What alternative way would there be for me to check whether or not a slot is empty?

The array is allocated dynamically.

EDIT: When I initialize the array, does it use the default constructor to create an object for each element of the array, or does it leave the elements empty?

Answer 1

If you have an array of objects of type X , none of the slots are "empty". They all contain an object of type X . To represent an empty object, it needs to be a possible state of the type which is stored in the array. You could, for example, have boost::optional<Slot> , or std::unique_ptr<Slot> . Otherwise, you can encode the state directly into your Slot class (with a bool member, for example).

Answer 2

What you want to do is store an array of Stock pointers, whereas you are currently storing an array of Slot objects. To make things even easier on yourself, you can use a vector to store the pointers.

Your backing data structure would look like this:

std::vector< Stock* > vecStocks;

Each item in the vector is a "slot", and you do not need your Slot class unless you intend to store some metadata about the stock.

To check whether or not you have a stock in any slot of the vector, you compare the vector item to NULL like this:

if (vecStocks[index] == NULL)

This approach has the positive side effect of not needing to allocate X number of Stock objects up front, where X is the size of your hashmap (potentially a very large number, depending on how often you like to collide).