看你能坚持多久。 
. e.g char* to double, long to int, etc.代码： 全选
/*
* hashmap.h
* Copyright (c) 2009 Vedant Kumar
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#pragma once
#define HMAP_PRESET_SIZE 2 << 6 // use a power of 2 for faster array access
#define HMAP_GROWTH_RATE 2
#define HMAP_MAKE_HASHFN
#define HMAP_THREAD_SAFE // build with -lrt
#define HMAP_DESTRUCTORS
#ifdef HMAP_THREAD_SAFE
#include <semaphore.h>
#endif
#include <stdint.h>
#include <stdlib.h>
#include <stdbool.h>
typedef void* key;
typedef void* val;
typedef struct key_val_map {
key k;
val v;
} key_val_map;
typedef struct hashmap {
key_val_map *map;
uint32_t size;
uint32_t capacity;
uint32_t (*hash_fn)(key);
bool (*eq_fn)(key, key);
#ifdef HMAP_DESTRUCTORS
void (*del_fn)(val);
#endif
#ifdef HMAP_THREAD_SAFE
sem_t lock;
#endif
} hashmap;
// hashmaps need a hash function, an equality function, and a destructor
hashmap mk_hmap(uint32_t (*hash_fn)(key),
bool (*eq_fn)(key, key)
#ifdef HMAP_DESTRUCTORS
, void (*del_fn)(val)
#endif
) {
hashmap hmap;
hmap.map = (key_val_map*) malloc(sizeof(key_val_map) * HMAP_PRESET_SIZE);
hmap.size = 0;
hmap.capacity = HMAP_PRESET_SIZE;
hmap.hash_fn = hash_fn;
hmap.eq_fn = eq_fn;
#ifdef HMAP_DESTRUCTORS
hmap.del_fn = del_fn;
#endif
#ifdef HMAP_THREAD_SAFE
sem_init(&hmap.lock, 0, 1);
#endif
return hmap;
}
void free_hmap(hashmap* hmap) {
#ifdef HMAP_THREAD_SAFE
sem_wait(&hmap->lock);
#endif
#ifdef HMAP_DESTRUCTORS
static uint32_t it;
for (it=0; it < hmap->size; ++it) {
if (hmap->map[it].v != NULL) {
hmap->del_fn(hmap->map[it].v);
}
}
#endif
free(hmap->map);
#ifdef HMAP_THREAD_SAFE
sem_post(&hmap->lock);
#endif
}
void __oa_hmap_add(key_val_map* map, uint32_t size, uint32_t (*hash_fn)(key),
key in, val out) {
static uint32_t hash;
hash = hash_fn(in) % size;
while (map[hash].v != NULL) {
hash = (hash + 1) % size;
}
map[hash].k = in;
map[hash].v = out;
}
bool __hmap_add(hashmap* hmap, key in, val out) {
#ifdef HMAP_THREAD_SAFE
sem_wait(&hmap->lock);
#endif
// performace degrades after a certain load
if (((float) hmap->size) / hmap->capacity > 0.70) {
key_val_map* temp = (key_val_map*) malloc(hmap->capacity * HMAP_GROWTH_RATE);
if (temp != NULL) {
hmap->capacity *= HMAP_GROWTH_RATE;
} else {
#ifdef HMAP_THREAD_SAFE
sem_post(&hmap->lock);
#endif
// we're out of memory
return false;
}
// re-posn all elements
static uint32_t it;
for (it=0; it < hmap->capacity; ++it) {
if (hmap->map[it].v != NULL) {
__oa_hmap_add(temp, hmap->capacity, hmap->hash_fn, in, out);
}
}
// swap out the old map with the new one
free(hmap->map);
hmap->map = temp;
}
__oa_hmap_add(hmap->map, hmap->capacity, hmap->hash_fn, in, out);
hmap->size += 1;
#ifdef HMAP_THREAD_SAFE
sem_post(&hmap->lock);
#endif
return true;
}
#define hmap_add(hmap, in, out) __hmap_add(&hmap, (key) in, (val) out)
val __hmap_get(hashmap* hmap, key in) {
#ifdef HMAP_THREAD_SAFE
sem_wait(&hmap->lock);
#endif
static uint32_t hash;
hash = hmap->hash_fn(in) % hmap->capacity;
while (hmap->map[hash].v != NULL) {
if (hmap->eq_fn(in, hmap->map[hash].k)) {
#ifdef HMAP_THREAD_SAFE
sem_post(&hmap->lock);
#endif
return hmap->map[hash].v;
}
hash = (hash + 1) % hmap->capacity;
}
#ifdef HMAP_THREAD_SAFE
sem_post(&hmap->lock);
#endif
return NULL;
}
#define hmap_get(hmap, obj) __hmap_get(&hmap, (val) obj)
#ifdef HMAP_MAKE_HASHFN
// Robert Jenkins' 32 bit integer hash function
uint32_t int_hash_fn(key in) {
static uint32_t a;
a = *((uint32_t*) in);
a = (a+0x7ed55d16) + (a<<12);
a = (a^0xc761c23c) ^ (a>>19);
a = (a+0x165667b1) + (a<<5);
a = (a+0xd3a2646c) ^ (a<<9);
a = (a+0xfd7046c5) + (a<<3);
a = (a^0xb55a4f09) ^ (a>>16);
return a;
}
bool int_eq_fn(key a, key b) {
return *((uint32_t*) a) == *((uint32_t*) b) ? true : false;
}
#endif
整点小技巧什么的吧