What is ** doing in this simple hash implemtation? - c++

Question

I know * defines a pointer... does ** define a pointer to a pointer?
If so, why?
Is a pointer to a pointer some times known as a reference? Just need clarification for the following very simple hash.
Generally pointers are used to pass the location of larger structures when passng the entire contents would be too costly.
I've seen pointers to pointers used in the quantlib project to create "handles" as each "observer" holds a pointer to a "term structure" pointer that might change at run-time, hence the pointer held the location of another pointer.
However I see no correlation here?
class hash_entry
{
private:
int key;
int value;
public:
hash_entry(int key, int value)
{
this->key = key;
this->value = value;
}
int getKey()
{
return key;
}
int getValue()
{
return value;
}
};
class hash_map
{
private:
hash_entry **table;
static const int TABLE_SIZE = 128;
public:
hash_map()
{
table = new hash_entry*[TABLE_SIZE];
for (int i = 0; i < TABLE_SIZE; i++)
table[i] = NULL;
}
int get(int key)
{
int hash = (key % TABLE_SIZE);
while (table[hash] != NULL && table[hash]->getKey() != key)
hash = (hash + 1) % TABLE_SIZE;
if (table[hash] == NULL)
return -1;
else
return table[hash]->getValue();
}
void put(int key, int value)
{
int hash = (key % TABLE_SIZE);
while (table[hash] != NULL && table[hash]->getKey() != key)
hash = (hash + 1) % TABLE_SIZE;
if (table[hash] != NULL)
delete table[hash];
table[hash] = new hash_entry(key, value);
}
~hash_map()
{
for (int i = 0; i < TABLE_SIZE; i++)
if (table[i] != NULL)
delete table[i];
delete[] table;
}
};

Answer 1

Yes, ** defines a pointer to a pointer (because the spec says so). No, I can't quite imagine anybody calling that a reference.
As to why they're using it in this case, they're writing (very C-like) code to dynamically allocate an array of pointers to X. This code:
hash_entry **table;
[ ... ]
hash_map() {
table = new hash_entry*[TABLE_SIZE];
Is roughly equivalent to:
std::vector<hash_entry *> table(TABLE_SIZE);
(though for the moment, I haven't split it up as you'd need to for a class member).

Answer 2

Yes, ** is a pointer to a pointer, but no, that's not the same as a reference. In this context, it's being used to create a dynamically-allocated two-dimensional array of hash_entry.
By the way, are you sure this code compiles? I see some things that appear to be syntax errors.

Answer 3

You are correct that ** refers to a pointer to a pointer (though incorrect that this is a reference - references are denoted with the ampersand - int & foo, for example).
In this case, it is being used not in the way you have described (as "handles"), but as an array of pointers to hash_entrys
The line:
table = new hash_entry*[TABLE_SIZE];
means "allocate a block of memory to hold hash_entry pointers, of size TABLE_SIZE * sizeof(hash_entry*). From there, the array is initialized to NULL, after which you can fill each entry in the array with a pointer as needed.

Answer 4

Yes, ** represents a pointer to a pointer.
One reason to add that extra level of indirection is so that you can move the thing ultimately pointed to around in physical memory without the code pointing to that something needing to be directly informed of the new address.
If a memory manager wants to move something in memory (for example, to reduce holes in a heap), it can allocate new memory, move the object, and update the address pointed to by the pointer-pointer to point to that new address.
Specifically in this case, if you have more hash entries than TABLE_SIZE, the code could reallocate hash_entry with a larger block of memory and update table with the new address of hash_entry. The rest of the code can be ignorant to the re-allocation.

Answer 5

I know * defines a pointer...does ** define a pointer to a pointer?
Yes.
If so why?
I'll assume you mean here why would someone use one, not how the types work (see any c reference for that). There are a few places I've seen and used them:
Dynamic array of pointers. (This is what we have here)
Dynamic 2-d arrays. (This is actually a subset of 1, a dynamic array where each element points to another dynamic array)
"Returning" a pointer via pointer passed as arg (*arg = ptr_to_return). See, e.g. getline()
Is a pointer to a pointer some times known as a reference? Just need clarification for the following very simple hash.
No, a reference is essentially passing by reference but letting the compiler keep track of the pointer for you.
Generally pointers are used to pass the location of larger structures when passng the entire contents would be too costly.
Yes, but not exclusively. Consider a method that changes a member of a struct. You need it to change YOUR copy of the struct, not the local copy it would have if you passed by value.
In your example here, hash_entry **table; is being used as a (dynamically sized) array of pointers to hash_entrys. It could, perhaps more clearly, be declared hash_entry *table[];