c开源hash项目 uthash

最新推荐文章于 2024-04-23 19:59:14 发布
最新推荐文章于 2024-04-23 19:59:14 发布
阅读量379 收藏
点赞数
分类专栏： Linux 文章标签： c算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wteruiycbqqvwt/article/details/118571087
版权

该开源代码采用宏的方式实现hash函数的相关功能（如查找、插入、删除等待），支持C语言的任意数据结构作为key值，甚至可以采用多个值作为key，无论是自定义的struct还是基本数据类型，需要注意的是不同类型的key其操作接口方式略有不通。

使用uthash代码时只需要包含头文件"uthash.h"即可。由于该代码采用宏的方式实现，所有的实现代码都在uthash.h文件中，因此只需要在自己的代码中包含该头文件即可。

1．uthash的效率

      uthash的插入、查找、删除的操作时间都是常量，当然这个常量的值受到key以及所选择的hash函数的影响，uthash共提供了7中函数函数，一般情况下选择默认的即可。

2、uthash的使用

      在hash操作中，都是按照“键-值“对的方式进行插、查等操作，在uthash中，其基本数据结构就是一个包含“键-值“对的结构体，另外，该结构体中还包含一个uthash内部使用的hash处理句柄，如下代码所示：

#include"uthash.h"  
struct my_struct {  
    int id;                    /* key */  
    char name[10];  
    UT_hash_handle hh;         /* makes this structure hashable */  
};  

其中：

  • id是键（key）；
  • name是值，即自己要保存的数据域，这里可以根据自己的需要让它变成结构体指针或者其他类型都可以；
  • hh是内部使用的hash处理句柄，在使用过程中，只需要在结构体中定义一个UT_hash_handle类型的变量即可，不需要为该句柄变量赋值，但必须在该结构体中定义该变量。
  •       Uthash所实现的hash表中可以提供类似于双向链表的操作，可以通过结构体成员hh的 hh.prev和hh.next获取当前节点的上一个节点或者下一个节点。

3．Key类型为int的简单示例

1）定义一个键为int类型的hash结构体：

#include "uthash.h"  
struct my_struct {  
    int ikey;                    /* key */  
    char value[10];  
    UT_hash_handle hh;           
     };  
     struct my_struct *g_users = NULL;  

这里需要注意:

  • key的类型为int，key的类型不一样，后面的插入、查找调用的接口函数就不一样，因此要求确保key的类型与uthash的接口函数一致。
  • 必须提供UT_hash_handle变量hh，无需为其初始化。
  • 定义一个hash结构的空指针g_users，用于指向保存数据的hash表，必须初始化为空，在后面的查、插等操作中，uthash内部会根据其是否为空而进行不同的操作。

2）实现自己的查找接口函数：

struct my_struct *find_user(int ikey) {  
    struct my_struct *s;  
    HASH_FIND_INT(g_users, &ikey, s );  
    return s;  
}  

其实现过程就是先定义一个hash结构体指针变量，然后通过HASH_FIND_INT接口找到该key所对应的hash结构体。这里需要注意：
  • Uthash为整型key提供的查找接口为HASH_FIND_INT；
  • 传给接口HASH_FIND_INT的第一个参数就是在1）中定义的指向hash表的指针，传入的第二个参数是整型变量ikey的地址。

3）实现自己的插入接口函数：

void add_user(int ikey, char *value_buf) {  
    struct my_struct *s;  
    HASH_FIND_INT(g_users, &ikey, s);  /* 先查看key值是否已经在hash表g_users里面了 */  
    if (s==NULL) {  
      s = (struct my_struct*)malloc(sizeof(struct my_struct));  
      s->ikey = ikey;  
      HASH_ADD_INT(g_users, ikey, s );  /* 自己定义的hash结构体中键变量的名字 */  
    }  
    strcpy(s-> value, value_buf);  
}  

由于uthash要求键（key）必须唯一，而uthash内部未对key值得唯一性进行很好的处理，因此它要求外部在插入操作时要确保其key值不在当前的hash表中，这就需要，在插入操作时，先查找hash表看其值是否已经存在，不存在在时再进行插入操作，在这里需要特别注意以下两点：

  • 插入时，先查找，当键不在当前的hash表中时再进行插入，以确保键的唯一性。
  • 需调用插入接口函数时需要明确告诉接口函数，自己定义的键变量的名字是什么。

4）实现删除接口

void delete_user(int ikey) {  
    struct my_struct *s = NULL;  
    HASH_FIND_INT(g_users, &ikey, s);  
    if (s!=NULL) {  
      HASH_DEL(g_users, s);   
      free(s);              
    }  
}  

删除操作的接口函数为HASH_DEL，只需要告诉该接口要释放哪个hash表（这里是g_users）里的哪个节点（这里是s），需要注意：释放申请的hash结构体变量，uthash函数只将结构体从hash表中移除，并未释放该结构体所占据的内存。

5）清空hash表

void delete_all() {  
  struct my_struct *current_user, *tmp;  
  HASH_ITER(hh, users, current_user, tmp) {  
    HASH_DEL(g_users,current_user);    
  free(current_user);              
  }  
}  

这里需要注意：uthash内部提供了另外一个清空函数:HASH_CLEAR(hh, g_users);函数，但它不释放各节点的内存，因此尽量不要使用它。

6）统计hash表中的已经存在的元素数

该操作使用函数HASH_COUNT即可获取到当前hash表中的元素数，其用法为：
unsigned int num_users;  
num_users = HASH_COUNT(g_users);  
printf("there are %u items\n", num_users);  

7）遍历元素

在开发过程中，可能需要对整个hash表进行遍历，这里可以通过hh.next获取当前元素的下一个元素。具体遍历方法为：
struct my_struct *s, *tmp;  
HASH_ITER(hh, g_users, s, tmp) {  
    printf("user ikey %d: value %s\n", s->ikey, s->value);  
    /* ... it is safe to delete and free s here */  
}  

另外还有一种不安全的删除方法，尽量避免使用它：

void print_users() {  
    struct my_struct *s;  
    for(s=g_users; s != NULL; s=s->hh.next) {  
        printf("user ikey %d: value %s\n", s->ikey, s->value);  
    }  
}  

4． 其他类型key的使用

本节主要关于key值类型为其他任意类型，例如整型、字符串、指针、结构体等时的用法。注意：在使用key值为浮点类型时，由于浮点类型的比较受到精度的影响，例如：1.0000000002被认为与1相等，这些问题在uthash中也存在。

4.1． int类型key

前面就是以int类型的key作为示例，总结int类型key使用方法，可以看到其查找和插入分别使用专用接口:HASH_FIND_INT和ASH_ADD_INT。

4.2． 字符指针char*类型key与字符数组char key[100]类型key

特别注意在Strting类型中，uthash对指针char*和字符数组（例如char key[100]）做了区分，这两种情况下使用的接口函数时不一样的。

在添加的时候，key的类型为指针时使用接口函数HASH_ADD_KEYPTR，

key的类型为字符数组时，使用接口函数HASH_ADD_STR，除了添加的接口不一样外，其他的查找、删除、变量等接口函数都是一样的。

4.3．使用地址作为key

在uthash中也可使用地址做key进行hash操作，使用地址作为key值时，其类型为void*，这样它就可以支持任意类型的地址了。在使用地址作为key时，插入和查找的专用接口函数为HASH_ADD_PTR和HASH_FIND_PTR
，其余接口是一样的。

4.4．其他非常用类型key

在uthash中还可使用结构体作为key，甚至可以采用组合的方式让多个值作为key，这些在其官方的网站张均有较详细的使用示例。在使用uthash需要注意以下几点：

  •  在定义hash结构体时不要忘记定义UT_hash_handle的变量
  •  需确保key值唯一，如果插入key-value对时，key值已经存在，再插入的时候就会出错。
  • 不同的key值，其增加和查找调用的接口函数不一样，具体可见第4节。一般情况下，不通类型的key，其插入和查找接口函数是不一样的，删除、遍历、元素统计接口是通用的，特殊情况下，字符数组和字符串作为key值时，其插入接口函数不一样，但是查找接口是一样的。

5．完整程序例子

5.1．key类型为int的完整的例子

#include <stdio.h>   /* gets */  
#include <stdlib.h>  /* atoi, malloc */  
#include <string.h>  /* strcpy */  
#include "uthash.h"  
  
struct my_struct {  
    int ikey;                    /* key */  
    char value[10];  
    UT_hash_handle hh;         /* makes this structure hashable */  
};  
  
static struct my_struct *g_users = NULL;  
  
void add_user(int mykey, char *value) {  
    struct my_struct *s;  
  
    HASH_FIND_INT(g_users, &mykey, s);  /* mykey already in the hash? */  
    if (s==NULL) {  
      s = (struct my_struct*)malloc(sizeof(struct my_struct));  
      s->ikey = mykey;  
      HASH_ADD_INT(g_users, ikey, s);  /* ikey: name of key field */  
    }  
    strcpy(s->value, value);  
}  
  
struct my_struct *find_user(int mykey) {  
    struct my_struct *s;  
  
    HASH_FIND_INT(g_users, &mykey, s);  /* s: output pointer */  
    return s;  
}  
  
void delete_user(struct my_struct *user) {  
    HASH_DEL(g_users, user);  /* user: pointer to deletee */  
    free(user);  
}  
  
void delete_all() {  
  struct my_struct *current_user, *tmp;  
  
  HASH_ITER(hh, g_users, current_user, tmp) {  
    HASH_DEL(g_users,current_user);  /* delete it (g_users advances to next) */  
    free(current_user);            /* free it */  
  }  
}  
  
void print_users() {  
    struct my_struct *s;  
  
    for(s=g_users; s != NULL; s=(struct my_struct*)(s->hh.next)) {  
        printf("user ikey %d: value %s\n", s->ikey, s->value);  
    }  
}  
  
int name_sort(struct my_struct *a, struct my_struct *b) {  
    return strcmp(a->value,b->value);  
}  
  
int id_sort(struct my_struct *a, struct my_struct *b) {  
    return (a->ikey - b->ikey);  
}  
  
void sort_by_name() {  
    HASH_SORT(g_users, name_sort);  
}  
  
void sort_by_id() {  
    HASH_SORT(g_users, id_sort);  
}  
  
int main(int argc, char *argv[]) {  
    char in[10];  
    int ikey=1, running=1;  
    struct my_struct *s;  
    unsigned num_users;  
  
    while (running) {  
        printf(" 1. add user\n");  
        printf(" 2. add/rename user by id\n");  
        printf(" 3. find user\n");  
        printf(" 4. delete user\n");  
        printf(" 5. delete all users\n");  
        printf(" 6. sort items by name\n");  
        printf(" 7. sort items by id\n");  
        printf(" 8. print users\n");  
        printf(" 9. count users\n");  
        printf("10. quit\n");  
        gets(in);  
        switch(atoi(in)) {  
            case 1:  
                printf("name?\n");  
                add_user(ikey++, gets(in));  
                break;  
            case 2:  
                printf("id?\n");  
                gets(in); ikey = atoi(in);  
                printf("name?\n");  
                add_user(ikey, gets(in));  
                break;  
            case 3:  
                printf("id?\n");  
                s = find_user(atoi(gets(in)));  
                printf("user: %s\n", s ? s->value : "unknown");  
                break;  
            case 4:  
                printf("id?\n");  
                s = find_user(atoi(gets(in)));  
                if (s) delete_user(s);  
                else printf("id unknown\n");  
                break;  
            case 5:  
                delete_all();  
                break;  
            case 6:  
                sort_by_name();  
                break;  
            case 7:  
                sort_by_id();  
                break;  
            case 8:  
                print_users();  
                break;  
            case 9:  
                num_users=HASH_COUNT(g_users);  
                printf("there are %u users\n", num_users);  
                break;  
            case 10:  
                running=0;  
                break;  
        }  
    }  
  
    delete_all();  /* free any structures */  
    return 0;  
}

5.2．key类型为字符数组的完整的例子

#include <string.h>  /* strcpy */  
#include <stdlib.h>  /* malloc */  
#include <stdio.h>   /* printf */  
#include "uthash.h"  
  
struct my_struct {  
    char name[10];             /* key (string is WITHIN the structure) */  
    int id;  
    UT_hash_handle hh;         /* makes this structure hashable */  
};  
  
  
int main(int argc, char *argv[]) {  
    const char **n, *names[] = { "joe", "bob", "betty", NULL };  
    struct my_struct *s, *tmp, *users = NULL;  
    int i=0;  
  
    for (n = names; *n != NULL; n++) {  
        s = (struct my_struct*)malloc(sizeof(struct my_struct));  
        strncpy(s->name, *n,10);  
        s->id = i++;  
        HASH_ADD_STR( users, name, s );  
    }  
  
    HASH_FIND_STR( users, "betty", s);  
    if (s) printf("betty's id is %d\n", s->id);  
  
    /* free the hash table contents */  
    HASH_ITER(hh, users, s, tmp) {  
      HASH_DEL(users, s);  
      free(s);  
    }  
    return 0;  
}

5.3．key类型为字符指针的完整的例子

#include <string.h>  /* strcpy */  
#include <stdlib.h>  /* malloc */  
#include <stdio.h>   /* printf */  
#include "uthash.h"  
  
struct my_struct {  
    const char *name;          /* key */  
    int id;  
    UT_hash_handle hh;         /* makes this structure hashable */  
};  
  
  
int main(int argc, char *argv[]) {  
    const char **n, *names[] = { "joe", "bob", "betty", NULL };  
    struct my_struct *s, *tmp, *users = NULL;  
    int i=0;  
  
    for (n = names; *n != NULL; n++) {  
        s = (struct my_struct*)malloc(sizeof(struct my_struct));  
        s->name = *n;  
        s->id = i++;  
        HASH_ADD_KEYPTR( hh, users, s->name, strlen(s->name), s );  
    }  
  
    HASH_FIND_STR( users, "betty", s);  
    if (s) printf("betty's id is %d\n", s->id);  
  
    /* free the hash table contents */  
    HASH_ITER(hh, users, s, tmp) {  
      HASH_DEL(users, s);  
      free(s);  
    }  
    return 0;  
}

panamera12
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
hash-开源
05-12
Hash是基于php的解决方案，用于在网站上注册用户，它使用php自动生成的代码来存储主要对用户数据有用的信息（用户名，密码等）
开源hash库
huang_yx005的博客
01-23 897
CMPH - C Minimal Perfect Hashing Library（最小完美哈希库） 官方网址http://cmph.sourceforge.net/
uthash哈希库使用详解（增删改查和遍历，示例代码）
最新发布
吻等离子的博客
04-23 1431
uthash库是一个在C语言中实现的轻量级哈希表库，它提供了高效的哈希表数据结构和简单易用的API，能够快速地将对象插入到哈希表中，并支持快速的查找、删除等操作。简单易用：uthash库提供了简洁的API，使用方便。高效性能：底层实现采用了高效的哈希算法和数据结构，能够在大量数据中快速进行操作。灵活性：可以轻松地在任何C语言项目中使用，而无需额外的依赖。uthash是一个功能强大的哈希库，可以帮助C语言开发者轻松实现哈希表的各种操作。本文提供了uthash的基本使用教程，希望对你有所帮助。
C中哈希开源hash代码uthash的原理与用法
jiuguaqiao6494的博客
06-30 535
开源hash代码uthash的原理与用法说明 说明 需要包含头文件 #include “uthash.h” 参考leedcode1 添加链接描述 struct hashTable { int key; int value; UT_hash_handle hh; }; struct hashTable *hash; struct hashTable *find(int key) { struct hashTable *tmp; HASH_FIND_INT(hash,
C的hash实现
sgua的专栏
02-18 916
网上讲解hash的基本原理，应用场景的文章浩如烟海，hash属于非常基础的内容，可以衍生出非常多的应用。 LeetCode上关于hash的原理讲解简单明确，可以参考：https://leetcode-cn.com/explore/learn/card/hash-table/ 重点关注： 1、hash处理中，key哈希后的冲突比例，一般来讲桶的大小是数据规模的2倍，这样可以有效防止key过于冲...
C语言 哈希表的简单实现
Serendipity_Shy
09-24 1411
C语言数据结构学习
C开源hash代码uthash
10-09
uthash 是C的比较优秀的开源代码，它实现了常见的hash操作函数，例如查找、插入、删除等待。该套开源代码采用宏的方式实现hash函数的相关功能，支持C语言的任意数据结构最为key值，甚至可以采用多个值作为key，无论...
uthash开源的hash函数实现
09-25
UTHASH 是一个开源的 C 语言库，提供了一种简单且高效的哈希表实现，用于在 C 代码中快速查找和管理数据结构。这个库的主要功能是提供一个宏定义的集合，可以方便地将结构体转化为哈希表，进而进行添加、删除、查找...
uthash-开源
05-14
使用UTHASH库，开发者可以轻松地在C语言项目中构建高性能的数据结构，同时保持代码的简洁和高效。这种库尤其适用于需要高效内存管理和快速数据操作的嵌入式系统或者系统级编程。由于它是开源的，用户可以自由地查看...
uthash库，c语言开源库，hash库
03-17
UTHash库是一个开源的C语言哈希表实现，它为C程序员提供了一种方便的方式来存储和查找数据。这个库的设计目标是简洁、高效且易于集成到现有的C项目中。通过使用UTHash，开发者可以快速地在C程序中实现动态数据结构，...
一个开源的哈希表源码实现
SE_craftsman的专栏
03-28 907
 struct entry...{    void *k, *v;    unsigned int h;    struct entry *next;};struct hashtable ...{    unsigned int tablelength;    struct entry **table;    unsigned int entrycount;    unsigned int
几种经典的Hash算法的实现(源代码)
08-13
这是几种经典的Hash算法的实现(源代码)，里面源代码和文字解说都有
哈希表C开源的uthash的简单初步封装（二）
Dancer__Sky的博客
11-22 654
概述：在上一篇博客中，简单封装了key为int类型的哈希表的增删，遍历等函数，但是在上一篇封装中，函数均是可见的，可能并不安全，所以这一次就将函数封装到结构体，像使用c++一样，直接通过结构体就可以运行函数。所有函数操作都是静态的，这样操作更加方便快捷。此次封装了key为int, char[],char * , void *四种类型的哈希表结构。在多线程中，依旧是不安全的，后期有时间会加入互斥锁，读
解读资产上链项目哈希未来（HSC）
weixin_42829334的博客
09-07 3284
哈希未来（HSC）介绍：数字资产的下一代区块链平台 哈希未来的愿景是打造社区共治、信任流动的“数字时代的阿⾥巴巴”——保证资产信息安全，流通 便捷⾼效，开创可信的数字时代。 哈希未来成⽴⾄今，社区⼀直秉承和贯彻着如下的核⼼价值主张： 1. 利⽤区块链技术，联通虚拟与现实，突破链上与链下的隔阂，让属于每个⼈的资产确权、⾃由流动。 2. 追求真理，尊᯿科学技术，开创可信的数字时代。形成学术严谨与⾃由...
uthash简介
热门推荐
Fan
07-10 1万+
文章目录C语言hash总结一、 uthash的使用Key类型为int时使用注意事项总结二、 完整的例子2.1 key为int2.2 key为字符数组2.3 key为字符 C语言hash总结 本文内容基本来自对官网的翻译，若有不准确的地方，望指正。 ​uthash 是C的比较优秀的开源代码，已经集成到最新的GCC。它实现了常见的hash操作函数，例如查找、插入、删除等待。该套开源代码采用宏的方式实现hash函数的相关功能，支持C语言的任意数据结构最为key值，甚至可以采用多个值作为key，无论是自定义的st
哈希表C开源的uthash的简单初步封装(一)
Dancer__Sky的博客
11-21 1062
概述：在自己项目中，数据处理过程我们或多或少可能都会用到哈希表，而自己去实现麻烦，效率又低。我就找了开源库uthash，这个库哈希表的实现，就是一个头文件（uthash.h）就实现了。但在我们具体使用，可能还是需要自己再封装一层，这样用起来可能更加方便简洁一些。因为也是刚接触这个一天，所以就先自己需要，封装了一个支持key值为int类型的哈希表。1,创建了一个sky_hash.c和一个sky_has
C函数学习（1）：uthash哈希表
Stoneshen的博客
08-07 1488
文章目录1 哈希表简介2 uthash2.1 定义结构体2.2 键类型为int2.2.1 插入2.2.2 查找2.2.3 删除2.2.4 替换2.2.5 计数2.2.6 遍历2.2.7 示例2.3 键类型为字符串2.4 键类型为字符串2.5 键类型为任意类型 1 哈希表简介 哈希表是一种基于key-value进行访问的数据结构，可以加快查找的速度，因此在一些需要快速查找是否有重复元素的场景中，常常使用哈希表来实现。 2 uthash C语言中不存在哈希，如果自己构建则会很麻烦。第三方开源的代码中已经实现哈希
uthash用法总结
Lin的博客
07-13 2136
目录前言1、简单介绍C语言中的HashTable支持的操作复杂度非库文件2、用法结构体定义键值key的唯一性UT_hash_handle内存消耗结构体声明添加查询删除清空哈希表统计hash表中的已经存在的元素数遍历排序key为int类型的完整示例 前言 本文旨在总结介绍C开源hash项目。文章大部分内容均来自uthash的英文使用文档。官方源码 uthash实现了常见的hash操作函数。使用uthash的代码时只需要包含头文件“uthash.h”即可。该套代码所有的实现都在uthash.h文件中，因此只需要
vscode 包含uthash.h
09-04
VSCode是一款功能强大的开源代码编辑器，它提供了丰富的功能和插件，方便开发者进行编程工作。VSCode本身并没有内置任何头文件或库文件，而是通过安装相应的插件来实现对特定功能的支持。 uthash.h是一个非常流行的C语言哈希表库，用于实现高效的哈希表操作。这个库提供了一系列的宏定义和函数，方便开发者进行哈希表的创建、插入、查找和删除等操作。 在VSCode中使用uthash.h，我们需要完成以下步骤： 1. 打开VSCode编辑器，确保已安装C/C++插件（如ms-vscode.cpptools）。 2. 在项目中创建一个名为uthash.h的文件，此文件可以从官方网站或其他地方下载获得。 3. 在项目的C源文件中，通过#include指令包含uthash.h头文件，以便在程序中使用uthash库提供的函数和宏定义。 例如，在项目的C源文件中，我们可以这样包含uthash.h： #include "uthash.h" int main() { // 使用uthash库创建哈希表，进行相关操作 // ... return 0; } 通过上述步骤，我们就可以在VSCode中使用uthash.h库进行哈希表操作了。 总结起来，VSCode本身不包含uthash.h，但我们可以通过安装C/C++插件并在项目中包含uthash.h头文件来使用uthash库。这样，我们就可以在VSCode中方便地进行哈希表相关的编程工作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值