在评论中，OP 提到他们从示例中学习得更好。 （这本身不是答案，只是一个示例。请将此视为扩展评论，而不是答案。）
那么，让我们看一个简单的真实示例；但不能只是复制粘贴并作为自己的作品呈现。
假设我们需要一个文本或标记的哈希表，比如说
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
struct hashentry {
struct hashentry *next;
size_t hash;
unsigned char data[];
};
struct hashtable {
size_t size;
struct hashentry **slot;
};
其中表本身是一个指针数组，哈希冲突通过链接解决。请注意，我基本上只使用键而不是键值对；这是为了避免将此示例代码复制粘贴并作为某人自己的工作呈现。我写这篇文章是为了帮助新程序员理解，而不是让作弊者提交作为他们的作业。 （请注意，我不是指 OP。这些问题通常是通过网络搜索找到的，我为整个群体编写这些答案，而不仅仅是提问者。）
表初始化到特定大小：
static inline void hashtable_init(struct hashtable *const ht, const size_t size)
{
size_t i;
if (!ht) {
fprintf(stderr, "hashtable_init(): No hashtable specified (ht == NULL).\n");
exit(EXIT_FAILURE);
} else
if (size < 1) {
fprintf(stderr, "hashtable_init(): Invalid hashtable size (size == %zu).\n", size);
exit(EXIT_FAILURE);
}
/* Allocate an array of pointers. */
ht->slot = calloc(size, sizeof ht->slot[0]);
if (!ht->slot) {
fprintf(stderr, "hashtable_init(): Failed to allocate an array of %zu slots.\n", size);
exit(EXIT_FAILURE);
}
ht->size = size;
/* Mark each slot unused. (On all current architectures, this is unnecessary,
as calloc() does initialize the pointers to NULL, but let's do it anyway.) */
for (i = 0; i < size; i++)
ht->slot[i] = NULL;
}
对于散列函数，我喜欢文本字符串的 DJB2 Xor 变体。不是特别好（会有碰撞），但是非常简单快速：
static inline size_t hash_data(const char *data, const size_t datalen)
{
const char *const ends = data + datalen;
size_t hash = 5381;
while (data < ends)
hash = (33 * hash) ^ (unsigned char)(*(data++));
return hash;
}
请注意，我使用size_t 作为散列的类型。你可以使用任何你想要的类型，但在大多数架构上，它的大小与指针相同，即 .
向哈希表添加数据条目：
static inline void hashtable_add(struct hashtable *ht, const char *data, const size_t datalen)
{
struct hashentry *entry;
size_t hash, slotnum;
if (!ht) {
fprintf(stderr, "hashtable_add(): No hashtable specified (ht == NULL).\n");
exit(EXIT_FAILURE);
} else
if (ht->size < 1) {
fprintf(stderr, "hashtable_add(): Hashtable has zero size.\n");
exit(EXIT_FAILURE);
} else
if (!data && datalen > 0) {
fprintf(stderr, "hashtable_add(): data is NULL, but datalen == %zu.\n", datalen);
exit(EXIT_FAILURE);
}
/* Allocate memory for the entry, including the data, and the string-terminating nul '\0'. */
entry = malloc(sizeof (struct hashentry) + datalen + 1);
if (!entry) {
fprintf(stderr, "hashtable_add(): Out of memory (datalen = %zu).\n", datalen);
exit(EXIT_FAILURE);
}
/* Copy the data, if any. */
if (datalen > 0)
memcpy(entry->data, data, datalen);
/* Ensure the data is terminated with a nul, '\0'. */
entry->data[datalen] = '\0';
/* Compute the hash. */
hash = hash_data(data, datalen);
entry->hash = hash;
/* The slot number is the hash modulo hash table size. */
slotnum = hash % ht->size;
/* Prepend entry to the corresponding slot chain. */
entry->next = ht->slot[slotnum];
ht->slot[slotnum] = entry;
}
当我最初编写上述代码时，我总是将其编写为测试程序，并对其进行测试。 （这在技术上属于unit testing 范式。）
在这种情况下，我们可以简单地将槽数作为命令行参数，从标准输入中读取每一行作为要添加到哈希表的数据。
因为标准 C 没有实现 getline()，我们最好使用 fgets() 来代替，并使用固定大小的行缓冲区。如果我们声明
#ifndef MAX_LINE_LEN
#define MAX_LINE_LEN 16383
#endif
我们有一个预处理器宏MAX_LINE_LEN，默认为 16383，但可以在编译时使用编译器选项覆盖。 （对于 GCC、Intel CC 和 clang，您可以使用例如 -DMAX_LINE_LEN=8191 将其减半。）
在main()中，如果参数计数不正确，或者-h或--help是第一个参数，我喜欢打印用法：
int main(int argc, char *argv[])
{
char buffer[MAX_LINE_LEN + 1];
char *line;
size_t size, i;
struct hashtable table;
char dummy;
if (argc != 2 || !strcmp(argv[1], "-h") || !strcmp(argv[1], "--help")) {
fprintf(stderr, "\n");
fprintf(stderr, "Usage: %s [ -h | --help ]\n", argv[0]);
fprintf(stderr, " %s ENTRIES < DATA-FILE > DOT-FILE\n", argv[0]);
fprintf(stderr, "\n");
fprintf(stderr, "This program reads lines from DATA-FILE, adding them to\n");
fprintf(stderr, "a hash table with ENTRIES slots and hash chaining.\n");
fprintf(stderr, "When all input lines have been read, the contents of the\n");
fprintf(stderr, "hash table slots will be output as a Graphviz DOT format graph.\n");
fprintf(stderr, "\n");
return EXIT_SUCCESS;
}
接下来，我们可以尝试将第一个命令行参数解析为size_t size;。我喜欢使用“哨兵”字符来检测参数值后面是否有垃圾（除了空格）：
if (sscanf(argv[1], "%zu %c", &size, &dummy) != 1 || size < 1) {
fprintf(stderr, "%s: Invalid number of hash table entries.\n", argv[1]);
return EXIT_FAILURE;
}
hashtable_init(&table, size);
下一部分是从标准输入中读取每一行，并将它们添加到哈希表中。
while (1) {
line = fgets(buffer, sizeof buffer, stdin);
if (!line)
break;
/* Skip leading ASCII whitespace. */
line += strspn(line, "\t\n\v\f\r ");
/* Find out the remaining length of the line. */
size = strlen(line);
/* Ignore trailing ASCII whitespace. */
while (size > 0 && (line[size-1] == '\t' || line[size-1] == '\n' ||
line[size-1] == '\v' || line[size-1] == '\f' ||
line[size-1] == '\r' || line[size-1] == ' '))
size--;
/* Ignore empty lines. */
if (size < 1)
continue;
/* Add line to the hash table. */
hashtable_add(&table, line, size);
}
/* Check if fgets() failed due to an error, and not EOF. */
if (ferror(stdin) || !feof(stdin)) {
fprintf(stderr, "Error reading from standard input.\n");
return EXIT_FAILURE;
}
此时，我们有 table 和 size 插槽。我编写测试程序来编写纯文本输出（如果简单）或 Graphviz DOT 格式输出（如果结构像图形）。在这种情况下，图形输出格式听起来更好。
/* Print the hash table contents as a directed graph, with slots as boxes. */
printf("digraph {\n");
for (i = 0; i < table.size; i++) {
struct hashentry *next = table.slot[i];
/* The slot box. */
printf(" \"%zu\" [ shape=\"box\", label=\"%zu\" ];\n", i, i);
if (next) {
/* The edge from the slot box to the entry oval. */
printf(" \"%zu\" -> \"%p\";\n", i, (void *)next);
while (next) {
struct hashentry *curr = next;
/* Each entry oval; text shown is the value read from the file. */
printf(" \"%p\" [ shape=\"oval\", label=\"%s\" ];\n", (void *)curr, curr->data);
next = next->next;
/* The edge to the next oval, if any. */
if (next)
printf(" \"%p\" -> \"%p\";\n", (void *)curr, (void *)next);
}
}
}
printf("}\n");
return EXIT_SUCCESS;
}
就是这样。如果以10作为命令行参数编译运行上面的程序，然后喂
one
two
three
four
five
six
seven
eight
nine
ten
到它的标准输入，它会输出
digraph {
"0" [ shape="box", label="0" ];
"1" [ shape="box", label="1" ];
"1" -> "0xb460c0";
"0xb460c0" [ shape="oval", label="three" ];
"0xb460c0" -> "0xb46080";
"0xb46080" [ shape="oval", label="one" ];
"2" [ shape="box", label="2" ];
"3" [ shape="box", label="3" ];
"3" -> "0xb46180";
"0xb46180" [ shape="oval", label="nine" ];
"0xb46180" -> "0xb460a0";
"0xb460a0" [ shape="oval", label="two" ];
"4" [ shape="box", label="4" ];
"4" -> "0xb46160";
"0xb46160" [ shape="oval", label="eight" ];
"0xb46160" -> "0xb46140";
"0xb46140" [ shape="oval", label="seven" ];
"5" [ shape="box", label="5" ];
"5" -> "0xb46100";
"0xb46100" [ shape="oval", label="five" ];
"6" [ shape="box", label="6" ];
"6" -> "0xb461a0";
"0xb461a0" [ shape="oval", label="ten" ];
"7" [ shape="box", label="7" ];
"7" -> "0xb46120";
"0xb46120" [ shape="oval", label="six" ];
"0xb46120" -> "0xb460e0";
"0xb460e0" [ shape="oval", label="four" ];
"8" [ shape="box", label="8" ];
"9" [ shape="box", label="9" ];
}
提供给 Graphviz dot 将生成一个漂亮的图表：
如果要查看数据字符串上方的实际哈希值，请更改为
/* Each entry oval; text shown is the value read from the file. */
printf(" \"%p\" [ shape=oval, label=\"%zu:\\n%s\" ];\n", (void *)curr, curr->hash, curr->data);
正如我所说，DJB2 Xor 哈希不是特别好，对于上述输入，您至少需要 43 个哈希表槽以避免链接。