这个迷你HashMap有什么问题？

Question

I am trying to implement a simple HashMap with only new get and insert functionalities. There's a very simple test function which is currently not passing.

The output:

test: Assertion `el == -10' failed.

When debugging the test, I get:

key: hhh value: 300
key: aba value: 300

When it shuold be:

key: hhh value: 10
key: aba value: -10

The code:

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#include<assert.h>

#define N (1000)
#define MULTIPLIER (37)

typedef struct Node {
    char* key;
    int value;
    struct Node* next;
} Node;

typedef struct HashMap {
    Node* data[N];
} HashMap;

void test();

unsigned long hash(const char* key);
HashMap* new_hash_map();
void insert_element(char* key, int value, HashMap* hm);
int get_element(char* key, HashMap* hm, int* el);

unsigned long hash (const char* s)
{
    unsigned long h;
    unsigned const char* us;

    us = (unsigned const char*) s;

    h = 0;
    while (*us != '\0'){
    h = h * MULTIPLIER + *us;
    us++;
    }
    return h % N;
}

HashMap* new_hash_map()
{
    HashMap* hm = malloc(sizeof(HashMap));
    for (int i = 0; i < N; i++){
    hm->data[i] = NULL;
    }
    return hm;
}
void insert_element(char* key, int value, HashMap* hm)
{
    unsigned long hk = hash(key);
    Node* ll = hm->data[hk];
    if (ll == NULL) {
    ll = malloc(sizeof(Node));
    ll->key = key;
    ll->value = value;
    ll->next = NULL;
    return;
    }
    for (; ll != NULL; ll = ll->next){
    if (strcmp(ll->key, key) == 0){
        // already exists
        ll->value = value;
        return;
    }
    }
    // new element, same hash key
    ll->key = key;
    ll->value = value;
    ll->next = NULL;
}

int get_element(char* key, HashMap* hm, int* el)
{
    unsigned long hk = hash(key);
    Node* ll = hm->data[hk];
    if (ll == NULL) {
    return -1;
    }
    for (; ll != NULL; ll = ll->next){
    if (strcmp(ll->key, key) == 0){
        // already exists
        *el = ll->value;
        return 1;
    }
    }
    return -1;
}

void test()
{
    HashMap* hm = new_hash_map();
    int el;
    insert_element("aba", 10, hm);
    insert_element("hhhh", -10, hm);
    get_element("hhhh", hm, &el);
    assert(el == -10);
    get_element("aba", hm, &el);
    assert(el == 10);
}

int main () {
    test();
    return 0;
}

Answer 1

Well the primary problem is that you never inserted anything, You got prepared , allocated and then assigned to appropriate members and then you simply returned from the function.

Assign the allocated memory to hashmap s data .( hm->data[hk] = ll ). Also check the return value of malloc .

Also the second loop is quite misleading in that - you end up with NULL in ll and then you dereference it. You should allocate and do the same thing as you did before.

   for (; ll != NULL; ll = ll->next){
    if (strcmp(ll->key, key) == 0){
        // already exists
        ll->value = value;
        return;
    }
    }
    // if the ll is NULL (in case it doesn't match) 
    // the you wil dereference NULL leading to UB.
    // new element, same hash key
    ll->key = key;
    ll->value = value;
    ll->next = NULL;

Dereferencing the NULL value is Undefined behavior. Here the probable solution would be to allocate memory for this new node and then assign it to a slot in hashmap.

From standard 6.5.3.2p4

The unary * operator denotes indirection. If the operand points to a function, the result is a function designator; if it points to an object, the result is an lvalue designating the object. If the operand has type ''pointer to type'', the result has type ''type''. If an invalid value has been assigned to the pointer, the behavior of the unary * operator is undefined .

On footnote

Among the invalid values for dereferencing a pointer by the unary * operator are a null pointer , an address inappropriately aligned for the type of object pointed to, and the address of an object after the end of its lifetime.