c++ 封装哈希表（Hash） 以及实现迭代器（iterator）

程序功能:

1.封装哈希表(Hash)

2.以及实现了迭代器(iterator)

3.允许string类，整形变量，浮点形变量，字符型变量等作为key值

废话不多说，马上上源码

Hash.h

/*
 *  Name: Hash
 *  Date: 14-12-2015
 *  Author: Sumkee
 *  Brief: 哈希模组
 *         1.能把string类，整形，浮点形，字符型变量当作key
 *         2.而且还实现了属于自己得迭代器（iterator）
 *
 */ 

#ifndef __HASH_H_
#define __HASH_H_

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <stdint.h>
#include <iterator>


using namespace std;


template<typename __Key, typename __Value>
class Hash {
public:
    enum {
        MaxKey = 10000000,    // 最大可存储数据
        MaxCharLenght = 128,  // 最长字符串
    };

    Hash();
    Hash(Hash<__Key, __Value> &src);
    ~Hash();

    // 访问函数
    inline size_t count() 
    {   return m_val_count; }
    
    inline size_t table_size() 
    {   return m_tb_size;   };   
    
    // 查看key值相对应得数据
    const __Value operator[](__Key key) 
    {   long index;
        if((index = __hash_keyindex_by_key(key, hash_keyindex(key))) > -1) return m_table[index];
        else return *m_empty;    }

    // 如上
    const __Value value(__Key key) 
    {   long index;
        if((index = __hash_keyindex_by_key(key, hash_keyindex(key))) > -1) return m_table[index];
        else return *m_empty;    }
    // 查看key值是否存在
    bool has_key(__Key key)
    {   return __hash_keyindex_by_key(key, hash_keyindex(key)) > -1;    }

    // 用数据逆向查看相对应的key值
    __Key key(__Value val);
    
    // 写入或修改函数
    void insert(__Key key, __Value val);
    void insert(pair<__Key, __Value> &key_and_val);
    void remove(__Key key);
    void operator=(Hash<__Key,__Value> &src);
    void clear();

    // 迭代器（用法和stl里提供的一样）
    class __Iterator;
    typedef __Iterator iterator;
    
    // 迭代器开始
    __Iterator begin() 
    {   int i=0;
        for(; i< m_tb_size && !m_is_setted[i]; ++i);
        return iterator(this, i);   }
    
    // 迭代器结束
    __Iterator end()
    {   return iterator(this, m_tb_size);   }

private:
    __Value *m_table;           // 哈希key值所对应数据表
    __Key *m_keys;              // 哈希key值所对应的所有key数据
    bool *m_is_setted;          // 查看m_table或m_keys的某下标是否已插入数据
    long m_tb_size;             // 哈希数据表大小，也就是m_table或m_keys的大小
    long m_val_count;           // 已插入数据总数
    __Value *m_oldtable;      
    __Key *m_oldkeys;
    bool *m_old_issetted;
    long m_old_tbsize;
    __Value *m_empty;           // 空的数据变量，用来返回空变量时用的

    /*  Name: hash_keyindex
     *  Brief: 透过哈希key值来获取数据所在位置的下标，也就是m_table[index]；
     *         不过这个函数主要判断key是否符合类型，除了下面得数据，其他会出错；
     *         它进一步获取下标是通过__hash_keyindex实现。
     *  return: 返回key值所对应的下标
     */
    long hash_keyindex(int8_t);
    long hash_keyindex(int16_t);
    long hash_keyindex(int32_t);
    long hash_keyindex(int64_t);
    long hash_keyindex(uint8_t);
    long hash_keyindex(uint16_t);
    long hash_keyindex(uint32_t);
    long hash_keyindex(uint64_t);
    long hash_keyindex(float);
    long hash_keyindex(double);
    long hash_keyindex(string &);
    long __hash_keyindex(u_char *first, size_t size);
    
    /*  Name:  __hash_null_keyindex 
     *  Brief: hash_keyindex是获取下标，不确定下标是否已经被占用；
     *         如果要确保下标是未被占用的，就需要调用hash_keyindex后，
     *         再调用__hash_null_keyindex。
     *  return: 返回key值所对应的下标
     */
    long __hash_null_keyindex(__Key &key, long key_index);

    /*  Name: __hash_keyindex_by_key
     *  Brief: 获取key值所在的下标，而且key值必须是存在的，也就是查找函数（value()，[]()）的核心。
     *         在调用此函数之前也需要调用hash_keyindex函数。
     *  return: 如果key值存在，就返回下标；否则返回-1
     */ 
    long __hash_keyindex_by_key(__Key &key, long key_index);

    /*  Name: reallocate
     *  Brief: 为m_tables, m_keys, m_is_setted等数据重新分配内存
     */ 
    void reallocate(long size);
    
    /*  Name: need_rehash, rehash
     *  Brief: need_rehash是判断是否有需要重新分配更大的内存，
     *         如果有需要得话它会调用reallocate，而reallocate在重新
     *         分配完内存后就会调用rehash将旧的数据重新用哈希的方法
     *         存放到新分配的内存地址，从而确保数据不丢失。
     */ 
    void need_rehash();
    void rehash();
    
    /*  Name: put_error
     *  Brief: 输出错误信息
     */ 
    void put_error(string str) 
    {   cout << "Hash:" << str << endl;  }
};

#endif

Hash.cpp

#include "hash.h"

template<typename __Key, typename __Value>
Hash<__Key, __Value>::Hash() : m_keys(0), m_table(0) 
,m_is_setted(0), m_tb_size(0), m_val_count(0), m_empty(0) {
    // 初始化，默认表大小为10
    reallocate(10);
}

template<typename __Key, typename __Value>
Hash<__Key, __Value>::Hash(Hash<__Key, __Value> &src) : m_keys(0), m_table(0)
,m_is_setted(0),m_tb_size(0),m_val_count(0), m_empty(0) {
    // 初始化，将别的Hash类复制过来
    reallocate(src.m_tb_size);
    for(int i=0; i<src.m_tb_size; ++i) {
        if(src.m_is_setted[i]) {
            insert(src.m_keys[i], src.m_table[i]);
        }
    }
}

template<typename __Key, typename __Value>
Hash<__Key, __Value>::~Hash() {
    // 释放内存
    clear();
}

template<typename __Key, typename __Value>
void 
Hash<__Key, __Value>::operator=(Hash<__Key,__Value> &src) {
    // 释放内存
    clear();

    // 将别的Hash类复制过来
    reallocate(src.m_tb_size);
    for(int i=0; i<src.m_tb_size; ++i) {
        if(src.m_is_setted[i]) {
            insert(src.m_keys[i], src.m_table[i]);
        }
    }
}

template<typename __Key, typename __Value>
void 
Hash<__Key, __Value>::clear() {
    if(m_keys) delete [] m_keys;
    if(m_table) delete [] m_table;
    if(m_is_setted) delete [] m_is_setted;
    if(m_empty) delete m_empty;
    m_keys = 0;
    m_table = 0;
    m_is_setted = 0;
    m_empty = 0;
    m_tb_size = 0;
    m_val_count = 0;
    reallocate(10);
}

template<typename __Key, typename __Value>
__Key 
Hash<__Key, __Value>::key(__Value val) {
    for(int i=0; i<m_tb_size; ++i) {
        if(m_is_setted[i]) {
            if(val == m_table[i]) {
                return m_keys[i];
            }
        }
    }
}

template<typename __Key, typename __Value>
long 
Hash<__Key,__Value>::hash_keyindex(int8_t key) {
    u_char *p = reinterpret_cast<u_char*>(&key);
    return __hash_keyindex(p, sizeof(int8_t));
}

template<typename __Key, typename __Value>
long 
Hash<__Key, __Value>::hash_keyindex(int16_t key) {
    u_char *p = reinterpret_cast<u_char*>(&key);
    return __hash_keyindex(p, sizeof(int16_t));
}

template<typename __Key, typename __Value>
long 
Hash<__Key, __Value>::hash_keyindex(int32_t key) {
    u_char *p = reinterpret_cast<u_char*>(&key);
    return __hash_keyindex(p, sizeof(int32_t));
}

template<typename __Key, typename __Value>
long 
Hash<__Key, __Value>::hash_keyindex(int64_t key) {
    u_char *p = reinterpret_cast<u_char*>(&key);
    return __hash_keyindex(p, sizeof(int64_t));
}

template<typename __Key, typename __Value>
long 
Hash<__Key, __Value>::hash_keyindex(uint8_t key) {
    u_char *p = reinterpret_cast<u_char*>(&key);
    return __hash_keyindex(p, sizeof(uint8_t));
}

template<typename __Key, typename __Value>
long 
Hash<__Key, __Value>::hash_keyindex(uint16_t key) {
    u_char *p = reinterpret_cast<u_char*>(&key);
    return __hash_keyindex(p, sizeof(uint16_t));
}

template<typename __Key, typename __Value>
long 
Hash<__Key, __Value>::hash_keyindex(uint32_t key) {
    u_char *p = reinterpret_cast<u_char*>(&key);
    return __hash_keyindex(p, sizeof(uint32_t));
}

template<typename __Key, typename __Value>
long 
Hash<__Key, __Value>::hash_keyindex(uint64_t key) {
    u_char *p = reinterpret_cast<u_char*>(&key);
    return __hash_keyindex(p, sizeof(uint64_t));
}

template<typename __Key, typename __Value>
long 
Hash<__Key, __Value>::hash_keyindex(float key) {
    u_char *p = reinterpret_cast<u_char*>(&key);
    return __hash_keyindex(p, sizeof(float));
}

template<typename __Key, typename __Value>
long 
Hash<__Key, __Value>::hash_keyindex(double key) {
    u_char *p = reinterpret_cast<u_char*>(&key);
    return __hash_keyindex(p, sizeof(double));
}

template<typename __Key, typename __Value>
long 
Hash<__Key, __Value>::hash_keyindex(string &key) {
    char tmp_data[MaxCharLenght] = {0}; 
    ::memcpy(tmp_data, key.data(), key.size());
    return __hash_keyindex((u_char*)tmp_data, key.size());
}

template<typename __Key, typename __Value>
long 
Hash<__Key, __Value>::__hash_keyindex(u_char *first, size_t size) {
    // 这里就是哈希算法，透过key值来查找下标
    ulong result=0;
    while(size--) {
        result = *first++ ^ result*0x1579532586542ul;
        result *= 0x35715ul;
    }
    return result%m_tb_size; 
}

template<typename __Key, typename __Value>
long 
Hash<__Key, __Value>::__hash_null_keyindex(__Key &key, long key_index) {
    while(1) {
        key_index = (key_index+1) % m_tb_size;
        if(!m_is_setted[key_index] || m_keys[key_index]==key) {
            return key_index;
        }
    }
}

template<typename __Key, typename __Value>
long 
Hash<__Key, __Value>::__hash_keyindex_by_key(__Key &key, long key_index) {
    long end = key_index;
    do {
        key_index = (key_index+1) % m_tb_size;
        if(m_is_setted[key_index] && m_keys[key_index]==key) {
            return key_index;
        } else if(!m_is_setted[key_index]) {
            break;
        }
    } while (key_index != end);
    return -1;
}

template<typename __Key, typename __Value>
void 
Hash<__Key, __Value>::reallocate(long size) {
    if(size > MaxKey) {
        put_error("too many key");
        return;
    }
        
    // 分配一个空数据
    if(m_empty == 0) {
        m_empty = new __Value;
    }

    // 保存旧数据 
    m_oldkeys = m_keys;
    m_oldtable = m_table;
    m_old_issetted = m_is_setted;
    m_old_tbsize = m_tb_size;

    // 申请新内存空间
    try {
        m_keys = new __Key[size];
        m_table = new __Value[size];
        m_is_setted = new bool[size];
        m_val_count = 0;

        if(!m_keys || !m_table || !m_is_setted) {
            throw "memory allocation error";
        }

        ::memset(m_is_setted, 0, size*sizeof(bool));
        m_tb_size = size;
    } catch(string err) {
        put_error(err);
    }

    // 将旧数据复制到新内存空间
    rehash();
    // 释放旧数据的内存空间
    delete [] m_oldkeys;
    delete [] m_oldtable;
    delete m_old_issetted;
    m_old_tbsize = 0;
}

template<typename __Key, typename __Value> 
void 
Hash<__Key, __Value>::need_rehash() {
    if(m_tb_size >= MaxKey) {
        return;
    }

    // 如果当前数据表空间的占用达到七成，就要重新分多一倍得空间出来
    double ratio = (double)m_val_count/m_tb_size;
    if(ratio >= 0.7) { 
        long size = m_tb_size*2;
        size = size >= MaxKey ? MaxKey : size;
        reallocate(size);
    }
}

template<typename __Key, typename __Value> 
void 
Hash<__Key, __Value>::rehash() {
    // 将旧数据复制新内存空间
    for(int i=0; i<m_old_tbsize; ++i) {
        if(m_old_issetted[i]) {
            insert(m_oldkeys[i],m_oldtable[i]);
        }
    }
}

template<typename __Key, typename __Value>
void 
Hash<__Key, __Value>::insert(__Key key, __Value val) {
    if(m_val_count >= MaxKey) {
        put_error("too many key");
        return;
    }

    // 判断是否需要重新分配内存
    need_rehash();

    // 插入
    long new_key_index = __hash_null_keyindex(key, hash_keyindex(key));
    if(m_keys[new_key_index] == key && m_is_setted[new_key_index]) {
        // 如果对应的key值已经存在，就修改对应得数据
        m_table[new_key_index] = val;
    } else {
        // 插入key值，数据，和将下标设为已占用
        m_table[new_key_index] = val;
        m_keys[new_key_index] = key;
        m_is_setted[new_key_index] = true;
        ++m_val_count;
    }
}

template<typename __Key, typename __Value>
void 
Hash<__Key, __Value>::insert(pair<__Key, __Value> &key_and_val) {
    insert(key_and_val.first, key_and_val.second);
}

template<typename __Key, typename __Value>
void 
Hash<__Key, __Value>::remove(__Key key) {
    // 删除key值对应的数据，其实就是将其下标设为未占用而已
    long key_index = __hash_keyindex_by_key(key, hash_keyindex(key));
    if(key_index != -1) {
        m_is_setted[key_index] = false;
        --m_val_count;
    }
}

// 这个就是迭代器的类
template<typename __Key, typename __Value>
class Hash<__Key, __Value>::__Iterator : 
public std::iterator<std::input_iterator_tag, std::pair<__Key, __Value> > {
    Hash<__Key, __Value> *phash;            // 指向hash类
    long hash_index;                        // 当前下标，指向key值和数据
    pair<__Key, __Value> hash_data;         // 将要返回的key值和数据塞进里面
public:
    __Iterator() : phash(0) , hash_index(0) {}
    __Iterator(Hash<__Key, __Value> *p, long i) : phash(p) , hash_index(i) {}

    // 前置递增， 将hash_index定位到下一个已存在得下标
    const __Iterator operator++() {
        int i;
        for(i=hash_index+1; i<phash->m_tb_size; ++i) { 
            if(phash->m_is_setted[i])  {
                break;
            }
        }
        hash_index = i;
        return *this;
    }
    // 后置递增， 也是将hash_index定位到下一个已存在得下标
    const __Iterator operator++(int) {
        __Iterator old(*this);
        int i;
        for(i=hash_index+1; i<phash->m_tb_size; ++i) { 
            if(phash->m_is_setted[i])  {
                break;
            }
        }
        hash_index = i;
        return old;
    }

    bool operator==(__Iterator iter) 
    { return (iter.phash==phash) && (iter.hash_index==iter.hash_index); }

    bool operator!=(__Iterator iter) 
    { return (iter.phash!=phash) || (hash_index!=iter.hash_index); }

    // 利用hash_index获取key值和数据，打包成pair类，最后返回
    const pair<__Key,__Value> operator*() 
    { return pair<__Key&, __Value&>(phash->m_keys[hash_index], phash->m_table[hash_index]); }
    
    const pair<__Key,__Value>* operator->() 
    {   hash_data.first = phash->m_keys[hash_index];
        hash_data.second = phash->m_table[hash_index];
        return &hash_data; }
};

/***************************************************/
// 测试
int main() {
    Hash<string, string> hash;
    hash.insert("a", "apple");
    hash.insert("b", "boy");
    hash.insert("c", "cat");
    hash.insert("d", "dog");
    hash.insert("f", "fire");

    // 查找
    cout << hash["a"] << endl;
    cout << hash["c"] << endl;
    cout << hash["f"] << endl;

    // 删除
    hash.remove("c");
    cout << "not cat:" << hash["c"] << endl; 

    // 利用迭代器遍历
    Hash<string,string>::iterator iter = hash.begin();
    for(; iter !=hash.end() ;++iter) {
        cout << iter->first << ":" << iter->second << endl;
    }
    return 0;
}

备注：本人编程新手，有错误请多多指点，谢谢。