通用哈希映射，不需要的输出（C）

我正在编写一个通用哈希表库，但在使用lookup（）之类的函数时一直遇到问题。 预期产出应为：

result = thirteen
result = thirteen
result = thirteen

但我得到：

result = thirteen

然后它崩溃了。当我多次调用lookup（）函数时，这个问题似乎就出现了，事实上，如果我调用lookup（）一次，代码运行时就没有任何问题

每次调用lookup（）函数时，它都会创建一个新的HashMap，但我看不出有更多的HashMap与问题之间有任何关联。 我试图在每个lookup（）函数之间使用free（）方法来解决这个问题，但问题不断出现

这是原始代码的一部分：

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

  typedef struct _Association Association;
  typedef struct _HashMap HashMap;
  typedef int (*HashMapCmp)(void*, void*);
  /*
    Hash Map
  */
  struct _HashMap{
    Association** array;
    int number_of_rows;
    int number_of_elements;
    HashMapCmp cmp_key;
  };

  /*
    element of the linked Hash Map
  */
  struct _Association{
    void* key;
    void* value;
    struct _Association* next;
  };

  /*
    hash function
  */
  unsigned int hash(HashMap* map, void* key){
      unsigned int hash_value = 0;
      hash_value = (*(int*)key * 1500) % map->number_of_rows;
      return hash_value;
  }

  /*
    inits a new Hash Map
  */
  HashMap* HashMap_new(int table_size, HashMapCmp cmp_key){
    HashMap* result = (HashMap*) malloc(sizeof(HashMap));
    result->number_of_rows = table_size;
    result->array = (Association**) malloc(sizeof(Association*) * result->number_of_rows);
    result->number_of_elements = 0;
    result->cmp_key = cmp_key;

    for(int i = 0; i < result->number_of_rows; i++){
      result->array[i] = malloc(sizeof(Association*));
      result->array[i] = NULL;
    }
    return result;
  }

  /*
    inserts a new association in my Hash Map
  */
  bool HashMap_insert(HashMap* map, void* key, void* value){
    if(map == NULL)
      return false;
    else{
      int index = hash(map, key);
      Association* as = malloc(sizeof(Association*));

      as->key = key;
      as->value = value;
      as->next = map->array[index];

      map->array[index] = as;
      map->number_of_elements++;

      return true;
    }
  }

  /*
    returns the value of the key passed by parameter
  */
  void* HashMap_lookup(HashMap* map, void* key){
    int index = hash(map, key);
    Association* tmp = map->array[index];

    while(tmp != NULL && map->cmp_key(tmp->key,key) != 0){
        tmp = tmp->next;
    }
    return tmp->value;
  }

  /*
    **************************************
    tests methods
  */

  /*
    int pointer (key)
  */
  int* int_new(int n) {
      int* result = (int*) malloc(sizeof(int));
      *result = n;
      return result;
  }

  /*
    char* pointer (value)
  */
  char** string_new(char* s) {
      char** result = (char**) malloc(sizeof(char*)*20);
      *result = s;
      return result;
  }

  /*
    Integers comparator -> obj1>obj2 = 1, obj1<obj2 = -1, obj1=obj2 = 0
  */

  static int compare_ints(int* obj1, int* obj2) {
      return *obj1 - *obj2;
  }

  /*
    creation of a 5 elements, high 4, HashMap
  */
  HashMap* create_five_elements_hash_map(){
    HashMap* map = HashMap_new(4, (HashMapCmp) compare_ints);

    HashMap_insert(map, int_new(0), string_new("zero"));
    HashMap_insert(map, int_new(13), string_new("thirteen"));
    HashMap_insert(map, int_new(22), string_new("twentytwo"));
    HashMap_insert(map, int_new(34), string_new("thirtyfour"));
    HashMap_insert(map, int_new(41), string_new("fortyone"));

    return map;
  }
  /*
    looking inside the Hashmap for the element
  */
  void test_lookup(){
    HashMap* map = create_five_elements_hash_map();
    char** str = (char**)HashMap_lookup(map,int_new(13));
    printf("result = %s\n", *str);
  }

  int main(){

    test_lookup();
    test_lookup();
    test_lookup();

    return 0;
  }

#包括
#包括
#包括
类型定义结构关联；
typedef struct_HashMap HashMap；
typedef int（*HashMapCmp）（void*，void*）；
/*
哈希映射
*/
结构哈希映射{
关联**数组；
整数行数；
元素的整数；
HashMapCmp_键；
};
/*
链接哈希映射的元素
*/
结构关联{
无效*键；
无效*值；
结构关联*下一步；
};
/*
散列函数
*/
无符号整数散列（HashMap*map，void*key）{
无符号整数散列值=0；
哈希值=（*（int*）键*1500）%map->行数；
返回哈希值；
}
/*
初始化一个新的哈希映射
*/
HashMap*HashMap\u新建（int table\u大小，HashMapCmp\u键）{
HashMap*result=（HashMap*）malloc（sizeof（HashMap））；
结果->行数=表格大小；
结果->数组=（关联**）malloc（sizeof（关联*）*结果->行数）；
结果->元素的数量=0；
结果->cmp\U键=cmp\U键；
对于（int i=0；iu行数；i++）{
结果->数组[i]=malloc（sizeof（Association*）；
结果->数组[i]=NULL；
}
返回结果；
}
/*
在我的哈希映射中插入新关联
*/
bool HashMap_insert（HashMap*map，void*键，void*值）{
if（map==NULL）
返回false；
否则{
int index=hash（映射，键）；
协会*as=malloc（协会*）；
as->key=key；
as->value=value；
as->next=map->array[index]；
映射->数组[索引]=as；
映射->元素数++；
返回true；
}
}
/*
返回参数传递的键的值
*/
void*HashMap_查找（HashMap*map，void*key）{
int index=hash（映射，键）；
关联*tmp=map->array[index]；
while（tmp！=NULL&&map->cmp_键（tmp->key，key）！=0）{
tmp=tmp->next；
}
返回tmp->value；
}
/*
**************************************
测试方法
*/
/*
int指针（键）
*/
int*int_新（int n）{
int*结果=（int*）malloc（sizeof（int））；
*结果=n；
返回结果；
}
/*
字符*指针（值）
*/
字符**字符串\新字符（字符*s）{
char**result=（char**）malloc（sizeof（char*）*20）；
*结果=s；
返回结果；
}
/*
整数比较器->obj1>obj2=1，obj1在HashMap中插入该行出错：

而且必须是

Association* as = malloc(sizeof(Association));

或

否则，只为1个指针分配内存，而关联需要为3个指针分配足够的空间，并且在设置为字段之后，以未定义的行为从分配的块中写入


如果您可以安装valgrind，我强烈建议您使用它，例如，如果我在我的PI4下对您的定义进行了安装，这里有很多信息：

pi@raspberrypi:/tmp $ gcc -g -Wall c.c
pi@raspberrypi:/tmp $ valgrind ./a.out
==6708== Memcheck, a memory error detector
==6708== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==6708== Using Valgrind-3.15.0 and LibVEX; rerun with -h for copyright info
==6708== Command: ./a.out
==6708== 
==6708== Invalid write of size 4
==6708==    at 0x10628: HashMap_insert (c.c:64)
==6708==    by 0x1081B: create_five_elements_hash_map (c.c:124)
==6708==    by 0x108F3: test_lookup (c.c:136)
==6708==    by 0x10943: main (c.c:143)
==6708==  Address 0x49e2244 is 0 bytes after a block of size 4 alloc'd
==6708==    at 0x4847690: malloc (vg_replace_malloc.c:309)
==6708==    by 0x1060B: HashMap_insert (c.c:61)
==6708==    by 0x1081B: create_five_elements_hash_map (c.c:124)
==6708==    by 0x108F3: test_lookup (c.c:136)
==6708==    by 0x10943: main (c.c:143)
==6708== 
==6708== Invalid write of size 4
==6708==    at 0x10648: HashMap_insert (c.c:65)
==6708==    by 0x1081B: create_five_elements_hash_map (c.c:124)
==6708==    by 0x108F3: test_lookup (c.c:136)
==6708==    by 0x10943: main (c.c:143)
==6708==  Address 0x49e2248 is 4 bytes after a block of size 4 alloc'd
==6708==    at 0x4847690: malloc (vg_replace_malloc.c:309)
==6708==    by 0x1060B: HashMap_insert (c.c:61)
==6708==    by 0x1081B: create_five_elements_hash_map (c.c:124)
==6708==    by 0x108F3: test_lookup (c.c:136)
==6708==    by 0x10943: main (c.c:143)
==6708== 
==6708== Invalid write of size 4
==6708==    at 0x10628: HashMap_insert (c.c:64)
==6708==    by 0x10843: create_five_elements_hash_map (c.c:125)
==6708==    by 0x108F3: test_lookup (c.c:136)
==6708==    by 0x10943: main (c.c:143)
==6708==  Address 0x49e2334 is 0 bytes after a block of size 4 alloc'd
==6708==    at 0x4847690: malloc (vg_replace_malloc.c:309)
==6708==    by 0x1060B: HashMap_insert (c.c:61)
==6708==    by 0x10843: create_five_elements_hash_map (c.c:125)
==6708==    by 0x108F3: test_lookup (c.c:136)
==6708==    by 0x10943: main (c.c:143)
...

但在修正之后：

pi@raspberrypi:/tmp $ valgrind ./a.out
==6844== Memcheck, a memory error detector
==6844== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==6844== Using Valgrind-3.15.0 and LibVEX; rerun with -h for copyright info
==6844== Command: ./a.out
==6844== 
result = thirteen
result = thirteen
result = thirteen
==6844== 
==6844== HEAP SUMMARY:
==6844==     in use at exit: 1,596 bytes in 66 blocks
==6844==   total heap usage: 67 allocs, 1 frees, 2,620 bytes allocated
==6844== 
==6844== LEAK SUMMARY:
==6844==    definitely lost: 108 bytes in 18 blocks
==6844==    indirectly lost: 1,488 bytes in 48 blocks
==6844==      possibly lost: 0 bytes in 0 blocks
==6844==    still reachable: 0 bytes in 0 blocks
==6844==         suppressed: 0 bytes in 0 blocks
==6844== Rerun with --leak-check=full to see details of leaked memory
==6844== 
==6844== For lists of detected and suppressed errors, rerun with: -s
==6844== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
pi@raspberrypi:/tmp $ 

因此，您不再有未定义的行为，但这并不意味着现在程序可以执行您想要的操作，但正如您所看到的，您存在内存泄漏，我鼓励您解决这些问题，并进一步了解它们：

pi@raspberrypi:/tmp $ valgrind --leak-check=full --show-leak-kinds=definite ./a.out
==6967== Memcheck, a memory error detector
==6967== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==6967== Using Valgrind-3.15.0 and LibVEX; rerun with -h for copyright info
==6967== Command: ./a.out
==6967== 
result = thirteen
result = thirteen
result = thirteen
==6967== 
==6967== HEAP SUMMARY:
==6967==     in use at exit: 1,596 bytes in 66 blocks
==6967==   total heap usage: 67 allocs, 1 frees, 2,620 bytes allocated
==6967== 
==6967== 4 bytes in 1 blocks are definitely lost in loss record 16 of 57
==6967==    at 0x4847690: malloc (vg_replace_malloc.c:309)
==6967==    by 0x1073F: int_new (c.c:96)
==6967==    by 0x108FF: test_lookup (c.c:137)
==6967==    by 0x10943: main (c.c:143)
==6967== 
==6967== 4 bytes in 1 blocks are definitely lost in loss record 17 of 57
==6967==    at 0x4847690: malloc (vg_replace_malloc.c:309)
==6967==    by 0x1073F: int_new (c.c:96)
==6967==    by 0x108FF: test_lookup (c.c:137)
==6967==    by 0x10947: main (c.c:144)
==6967== 
==6967== 4 bytes in 1 blocks are definitely lost in loss record 18 of 57
==6967==    at 0x4847690: malloc (vg_replace_malloc.c:309)
==6967==    by 0x1073F: int_new (c.c:96)
==6967==    by 0x108FF: test_lookup (c.c:137)
==6967==    by 0x1094B: main (c.c:145)
==6967== 
==6967== 16 bytes in 4 blocks are definitely lost in loss record 37 of 57
==6967==    at 0x4847690: malloc (vg_replace_malloc.c:309)
==6967==    by 0x1056F: HashMap_new (c.c:47)
==6967==    by 0x107EF: create_five_elements_hash_map (c.c:122)
==6967==    by 0x108F3: test_lookup (c.c:136)
==6967==    by 0x10943: main (c.c:143)
==6967== 
==6967== 16 bytes in 4 blocks are definitely lost in loss record 38 of 57
==6967==    at 0x4847690: malloc (vg_replace_malloc.c:309)
==6967==    by 0x1056F: HashMap_new (c.c:47)
==6967==    by 0x107EF: create_five_elements_hash_map (c.c:122)
==6967==    by 0x108F3: test_lookup (c.c:136)
==6967==    by 0x10947: main (c.c:144)
==6967== 
==6967== 16 bytes in 4 blocks are definitely lost in loss record 39 of 57
==6967==    at 0x4847690: malloc (vg_replace_malloc.c:309)
==6967==    by 0x1056F: HashMap_new (c.c:47)
==6967==    by 0x107EF: create_five_elements_hash_map (c.c:122)
==6967==    by 0x108F3: test_lookup (c.c:136)
==6967==    by 0x1094B: main (c.c:145)
==6967== 
==6967== 512 (16 direct, 496 indirect) bytes in 1 blocks are definitely lost in loss record 55 of 57
==6967==    at 0x4847690: malloc (vg_replace_malloc.c:309)
==6967==    by 0x104F7: HashMap_new (c.c:40)
==6967==    by 0x107EF: create_five_elements_hash_map (c.c:122)
==6967==    by 0x108F3: test_lookup (c.c:136)
==6967==    by 0x10943: main (c.c:143)
==6967== 
==6967== 512 (16 direct, 496 indirect) bytes in 1 blocks are definitely lost in loss record 56 of 57
==6967==    at 0x4847690: malloc (vg_replace_malloc.c:309)
==6967==    by 0x104F7: HashMap_new (c.c:40)
==6967==    by 0x107EF: create_five_elements_hash_map (c.c:122)
==6967==    by 0x108F3: test_lookup (c.c:136)
==6967==    by 0x10947: main (c.c:144)
==6967== 
==6967== 512 (16 direct, 496 indirect) bytes in 1 blocks are definitely lost in loss record 57 of 57
==6967==    at 0x4847690: malloc (vg_replace_malloc.c:309)
==6967==    by 0x104F7: HashMap_new (c.c:40)
==6967==    by 0x107EF: create_five_elements_hash_map (c.c:122)
==6967==    by 0x108F3: test_lookup (c.c:136)
==6967==    by 0x1094B: main (c.c:145)
==6967== 
==6967== LEAK SUMMARY:
==6967==    definitely lost: 108 bytes in 18 blocks
==6967==    indirectly lost: 1,488 bytes in 48 blocks
==6967==      possibly lost: 0 bytes in 0 blocks
==6967==    still reachable: 0 bytes in 0 blocks
==6967==         suppressed: 0 bytes in 0 blocks
==6967== 
==6967== For lists of detected and suppressed errors, rerun with: -s
==6967== ERROR SUMMARY: 9 errors from 9 contexts (suppressed: 0 from 0)
pi@raspberrypi:/tmp $ 

我猜你出车祸了。在调试器中运行您的程序，查看它是否捕获到崩溃。如果没有，则使用调试器逐语句逐步检查代码语句，以确保其按预期工作。此外，还可以使用详细的警告构建程序，并将警告视为必须修复的错误。不过，有一些东西非常突出，例如
string\u new
函数。创建一个包含20个指向字符串指针的数组，并且只初始化并使用该数组的第一个元素的目的是什么？更不用说你只复制了指针
s
，而不是
s
可能指向的字符串。另一件突出的事情是，
result->array[i]=malloc（…）
直接后跟
result->array[i]=NULL
。我明白了，所以我不应该做malloc（），而应该做result->array[i]=NULL对吗？@SamuelMagnano您的一个分配错误，请看我的答案
pi@raspberrypi:/tmp $ valgrind ./a.out
==6844== Memcheck, a memory error detector
==6844== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==6844== Using Valgrind-3.15.0 and LibVEX; rerun with -h for copyright info
==6844== Command: ./a.out
==6844== 
result = thirteen
result = thirteen
result = thirteen
==6844== 
==6844== HEAP SUMMARY:
==6844==     in use at exit: 1,596 bytes in 66 blocks
==6844==   total heap usage: 67 allocs, 1 frees, 2,620 bytes allocated
==6844== 
==6844== LEAK SUMMARY:
==6844==    definitely lost: 108 bytes in 18 blocks
==6844==    indirectly lost: 1,488 bytes in 48 blocks
==6844==      possibly lost: 0 bytes in 0 blocks
==6844==    still reachable: 0 bytes in 0 blocks
==6844==         suppressed: 0 bytes in 0 blocks
==6844== Rerun with --leak-check=full to see details of leaked memory
==6844== 
==6844== For lists of detected and suppressed errors, rerun with: -s
==6844== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
pi@raspberrypi:/tmp $ 

pi@raspberrypi:/tmp $ valgrind --leak-check=full --show-leak-kinds=definite ./a.out
==6967== Memcheck, a memory error detector
==6967== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==6967== Using Valgrind-3.15.0 and LibVEX; rerun with -h for copyright info
==6967== Command: ./a.out
==6967== 
result = thirteen
result = thirteen
result = thirteen
==6967== 
==6967== HEAP SUMMARY:
==6967==     in use at exit: 1,596 bytes in 66 blocks
==6967==   total heap usage: 67 allocs, 1 frees, 2,620 bytes allocated
==6967== 
==6967== 4 bytes in 1 blocks are definitely lost in loss record 16 of 57
==6967==    at 0x4847690: malloc (vg_replace_malloc.c:309)
==6967==    by 0x1073F: int_new (c.c:96)
==6967==    by 0x108FF: test_lookup (c.c:137)
==6967==    by 0x10943: main (c.c:143)
==6967== 
==6967== 4 bytes in 1 blocks are definitely lost in loss record 17 of 57
==6967==    at 0x4847690: malloc (vg_replace_malloc.c:309)
==6967==    by 0x1073F: int_new (c.c:96)
==6967==    by 0x108FF: test_lookup (c.c:137)
==6967==    by 0x10947: main (c.c:144)
==6967== 
==6967== 4 bytes in 1 blocks are definitely lost in loss record 18 of 57
==6967==    at 0x4847690: malloc (vg_replace_malloc.c:309)
==6967==    by 0x1073F: int_new (c.c:96)
==6967==    by 0x108FF: test_lookup (c.c:137)
==6967==    by 0x1094B: main (c.c:145)
==6967== 
==6967== 16 bytes in 4 blocks are definitely lost in loss record 37 of 57
==6967==    at 0x4847690: malloc (vg_replace_malloc.c:309)
==6967==    by 0x1056F: HashMap_new (c.c:47)
==6967==    by 0x107EF: create_five_elements_hash_map (c.c:122)
==6967==    by 0x108F3: test_lookup (c.c:136)
==6967==    by 0x10943: main (c.c:143)
==6967== 
==6967== 16 bytes in 4 blocks are definitely lost in loss record 38 of 57
==6967==    at 0x4847690: malloc (vg_replace_malloc.c:309)
==6967==    by 0x1056F: HashMap_new (c.c:47)
==6967==    by 0x107EF: create_five_elements_hash_map (c.c:122)
==6967==    by 0x108F3: test_lookup (c.c:136)
==6967==    by 0x10947: main (c.c:144)
==6967== 
==6967== 16 bytes in 4 blocks are definitely lost in loss record 39 of 57
==6967==    at 0x4847690: malloc (vg_replace_malloc.c:309)
==6967==    by 0x1056F: HashMap_new (c.c:47)
==6967==    by 0x107EF: create_five_elements_hash_map (c.c:122)
==6967==    by 0x108F3: test_lookup (c.c:136)
==6967==    by 0x1094B: main (c.c:145)
==6967== 
==6967== 512 (16 direct, 496 indirect) bytes in 1 blocks are definitely lost in loss record 55 of 57
==6967==    at 0x4847690: malloc (vg_replace_malloc.c:309)
==6967==    by 0x104F7: HashMap_new (c.c:40)
==6967==    by 0x107EF: create_five_elements_hash_map (c.c:122)
==6967==    by 0x108F3: test_lookup (c.c:136)
==6967==    by 0x10943: main (c.c:143)
==6967== 
==6967== 512 (16 direct, 496 indirect) bytes in 1 blocks are definitely lost in loss record 56 of 57
==6967==    at 0x4847690: malloc (vg_replace_malloc.c:309)
==6967==    by 0x104F7: HashMap_new (c.c:40)
==6967==    by 0x107EF: create_five_elements_hash_map (c.c:122)
==6967==    by 0x108F3: test_lookup (c.c:136)
==6967==    by 0x10947: main (c.c:144)
==6967== 
==6967== 512 (16 direct, 496 indirect) bytes in 1 blocks are definitely lost in loss record 57 of 57
==6967==    at 0x4847690: malloc (vg_replace_malloc.c:309)
==6967==    by 0x104F7: HashMap_new (c.c:40)
==6967==    by 0x107EF: create_five_elements_hash_map (c.c:122)
==6967==    by 0x108F3: test_lookup (c.c:136)
==6967==    by 0x1094B: main (c.c:145)
==6967== 
==6967== LEAK SUMMARY:
==6967==    definitely lost: 108 bytes in 18 blocks
==6967==    indirectly lost: 1,488 bytes in 48 blocks
==6967==      possibly lost: 0 bytes in 0 blocks
==6967==    still reachable: 0 bytes in 0 blocks
==6967==         suppressed: 0 bytes in 0 blocks
==6967== 
==6967== For lists of detected and suppressed errors, rerun with: -s
==6967== ERROR SUMMARY: 9 errors from 9 contexts (suppressed: 0 from 0)
pi@raspberrypi:/tmp $