c++ 实现hashmap

由于hashmap不是c++ stl中标准实现，这样在跨平台使用时就可能会出现问题，于是想到自己实现一个hashmap

hash算法使用开链法解决hash冲突，主要实现了添加，删除，查找几个方法

头文件如下hashmap.h

#include <iostream>
#include <string>


using namespace std; 
 
template<class Key, class Value>
class HashNode
{
public:
    Key    _key;
    Value  _value;
    HashNode *next;
 
    HashNode(Key key, Value value)
    {
        _key = key;
        _value = value;
        next = nullptr;
    }
    ~HashNode()
    {
 
    }
    HashNode& operator=(const HashNode& node)
    {
        _key = node.key;
        _value = node.key;
        next = node.next;
        return *this;
    }
};
 
template <class Key, class Value, class HashFunc, class EqualKey>
class HashMap
{
public:
    HashMap(int size);
    ~HashMap();
    bool insert(const Key& key, const Value& value);
    bool del(const Key& key);
    Value& find(const Key& key);
    Value& operator [](const Key& key);
 
private:
    HashFunc hash;
    EqualKey equal;
    HashNode<Key, Value> **table;
    unsigned int _size;
    Value ValueNULL;
};
 
 
template <class Key, class Value, class HashFunc, class EqualKey>
HashMap<Key, Value, HashFunc, EqualKey>::HashMap(int size) : _size(size)
{
    hash = HashFunc();
    equal = EqualKey();
    table = new HashNode<Key, Value> *[_size];
    for (unsigned i = 0; i < _size; i++)
        table[i] = nullptr;
}
 
 
 
template <class Key, class Value, class HashFunc, class EqualKey>
HashMap<Key, Value, HashFunc, EqualKey>::~HashMap()
{
    for (unsigned i = 0; i < _size; i++)
    {
        HashNode<Key, Value> *currentNode = table[i];
        while (currentNode)
        {
            HashNode<Key, Value> *temp = currentNode;
            currentNode = currentNode->next;
            delete temp;
        }
    }
    delete table;
}
 
 
template <class Key, class Value, class HashFunc, class EqualKey>
bool HashMap<Key, Value, HashFunc, EqualKey>::insert(const Key& key, const Value& value)
{
    int index = hash(key) % _size;
    HashNode<Key, Value> *node = new HashNode<Key, Value>(key,value);
    node->next = table[index];
    table[index] = node;
    return true;
}
 
 
template <class Key, class Value, class HashFunc, class EqualKey>
bool HashMap<Key, Value, HashFunc, EqualKey>::del(const Key& key)
{
    unsigned index = hash(key) % _size;
    HashNode<Key, Value> * node = table[index];
    HashNode<Key, Value> * prev = nullptr;
    while (node)
    {
        if (node->_key == key)
        {
            if (prev == nullptr)
            {
                table[index] = node->next;
            }
            else
            {
                prev->next = node->next;
            }
            delete node;
            return true;
        }
        prev = node;
        node = node->next;
    }
    return false;
}
 
template <class Key, class Value, class HashFunc, class EqualKey>
Value& HashMap<Key, Value, HashFunc, EqualKey>::find(const Key& key)
{
    unsigned  index = hash(key) % _size;
    if (table[index] == nullptr)
        return ValueNULL;
    else
    {
        HashNode<Key, Value> * node = table[index];
        while (node)
        {
        	cout << "node->_key = " << node->_key << endl;
            if (node->_key == key)
                return node->_value;
            node = node->next;
        }


		cout << "key is not find!" << endl;
		return ValueNULL;
    }
}
 
 
template <class Key, class Value, class HashFunc, class EqualKey>
Value& HashMap<Key, Value, HashFunc, EqualKey>::operator [](const Key& key)
{
    return find(key);
}

测试代码

//首先要定义hash函数与比较函数
class HashFunc
{
public:
    int operator()(const string & key)
    {
        int hash = 0;
        for(int i = 0; i < key.length(); ++i)
        {
            hash = hash << 7 ^ key[i];
        }
        return (hash & 0x7FFFFFFF);


		//return 0;
    }
};
 
 
class EqualKey
{
public:
    bool operator()(const string & A, const string & B)
    {
        if (A.compare(B) == 0)
            return true;
        else
            return false;
    }
};

int main()
{
    HashMap<string, string, HashFunc, EqualKey> hashmap(100);
 
    hashmap.insert("hello", "world");
    hashmap.insert("why", "dream");
    hashmap.insert("c++", "good");
    hashmap.insert("welcome", "haha");
 
    
    cout << "after insert:" << endl;
    cout << hashmap.find("welcome").c_str() << endl;
    cout << hashmap.find("c++").c_str() << endl;
    cout << hashmap["why"].c_str() << endl;
    cout << hashmap["hello"].c_str() << endl;
 
    if (hashmap.del("hello"))
        cout << "remove is ok" << endl;    //remove is ok
    cout << hashmap.find("hello").c_str() << endl; //not exist print NULL
 
    hashmap["why"] = "love";
    cout << hashmap["why"].c_str() << endl;


	HashMap<string, string, HashFunc, EqualKey> hashmap1(6);
	hashmap1.insert("zhang", "I am zhang");
	hashmap1.insert("xiao", "I am xiao");
	hashmap1.insert("zhang", "I am ying");
	cout << hashmap1["zhang1"].c_str() << endl;
	//cout << hashmap1[6].c_str() << endl;
	
    return 0;
}