Implementation of hash map I was asked to implement a hash map in this phone interview (screen-share), so time was limited and this is what I came up with. I'd appreciate if someone can take a minute to critique/review it and help me improve.

Here is an online version of the code.

#include &lt;list&gt;
#include &lt;iostream&gt;
using namespace std;

const int SIZE = 10;

class Node{
public:
    Node(){}
    Node(int k, int v):key(k), value(v){}
    int key, value;
};

class HashMap {
private:
    list&lt;Node*&gt; data[SIZE];

public:
    ~HashMap();
    Node* get(int key);
    void put(int key, int value);

    int hashFn(int val){ return val % 13; }
};

Node* HashMap::get(int key){
    int hashValue = hashFn(key);
    int bucket = hashValue % SIZE;
    list&lt;Node*&gt;::iterator it = data[bucket].begin();

    while(it != data[bucket].end()){

        Node ** d = &amp;(*it); 
        if((*d)-&gt;key == key){
            return *d;
        }

        it++;
    }
    return NULL;
}

void HashMap::put(int key, int value){
    int hashValue = hashFn(key);
    int bucket = hashValue % SIZE;
    Node* node = this-&gt;get(key);
    if(node == NULL){
        data[bucket].push_front(new Node(key, value));
    }
    else{
        node-&gt;value = value;
    }
}

HashMap::~HashMap(){
    for(int i = 0; i &lt; SIZE; ++i){
        list&lt;Node*&gt;&amp; val = data[i];
        for(list&lt;Node*&gt;::iterator it = val.begin(); it != val.end(); it++){
            Node* n = *it;
            delete n;
        }
    }
}

int main(){
    HashMap map;
    cout &lt;&lt; "Finding 5: " &lt;&lt; map.get(5) &lt;&lt; endl;  // -1
    map.put(5, 10);
    map.put(5, 11);
    cout &lt;&lt; "Finding 5: " &lt;&lt; map.get(5)-&gt;value;  // 11
    return 1;
}
Some obvious problems


It leaks memory (every newly allocated Node) when the Hashmap leaves the scope.
A delete/remove function is missing.
It doesn't replace the value within the existing Node on repeated puts with the same key but instead adds an additional Node every time.
The size is fixed and therefore the hashmap get quickly degenerates into linked list search.
Key and value types aren't generic.


Some positive things


It implements a hashmap 
uses hash-lookup for search 
returns correct results