C++中使用STL的hashmap

我们就来分析一下hash_map的教程：

简单变量作为索引：

整形，实性，指针型，

hash_map<int, int >inthash;

inthash[1] = "123";

inthash[2] = "456";

int val = inthash[1];

int val = inthash[2];

hash_map<const char*, int >charhash;

charhash["a"] = 123;

charhash["b"] = 456;

char szinput[64] = "";

scanf("%s", szinput);

int val = charhash[szinput];

最终的结果无论输入任何字符串否无法找到对应的整数值，因为输入的字符串指针是szinput, 和"a"或"b"字符串常量指针永远不可能相等；

解决办法如下：

首先写一个仿函数charless()继承自函数基类binary_function（当然也可以不继承）

struct charless :public binary_function(const char*, const char, bool)

{

public:

result_type operate()(const first_argument_type&_left, const second_argument_type&_right) const

{

return (stricmp(_left, _right) < 0 ? true : false);

}

};

那么有了这个仿函数，我们就可以正确的使用字符穿hash_map了；

hash_map<const char*, int, hash_map<const char *, charless>> charhash

charhash["a"] = 123;

charhash["b"] = 456;

char szinput[64] = "";

scanf("%s", szinput);

int val = charhash[szinput];

那么这个时候，简单类型的使用方法介绍完毕：

另外：微软为标准的basic_string(string 的基类)提供了hash的方法：

虽然支持string 的hash; 而hash类却没有重载运算比较符，所以以前的hash_compare仍然无法工作：

struct string_less :public binary_function<const string, const string, bool>

{

public:

result_type
operator()(const first_argument_type& _left, const second_argument_type&_right)const

{

return (_left.compare(_right) < 0 ? true : false);

}

};

好了，我们可以书写如下代码：

hash_map<int, string, compare<string, string_less>>stringhash

{

stringhash["a"] = 123;

stringhash["b"] = 456;

string strkey = "a";

int val = charhash[strkey];

}

对于微软的cstring，其重载了比较运算符，所以我么必须重写hash_compare放函数：

那么在头文件#include <atlstr.h>

中包含了 ，我们运用头文件就可以使用了；

下面我们来使用 hash_value()

inline size_t cstring_hash_value(const cstring &str)

{

size_t value = _HASH_SEED;

size_t size = str.getlength();

if (size > 0)

{

size_t temp = size / 16 + 1;

size -= temp;

for (size_t index = 0; index < size; i += temp)

{

value += (size_t)str[(int)index];

}

}

return value;

}

其次重写hash_compare()函数：

class cstring_hash_value :public hash_compare<cstring>

{

public:

size_t operator()(const cstring &_key)const

{

return
(size_t)cstring_hash_value(_key);

}

bool operator()(const cstring & string1, const cstring& string 2)

{

return (comp(string1, string2));

}

};

上面的重载忽略了对于less（）仿函数的应用：

因为cstring 具有比较运算符：

那么我们可以使用默认的less仿函数，在这里映射为comn（）函数好了我么可以声明新的hash_map对象了：

hash_map<cstring, int, CString_compare >cstringhash

其余的操作是一样的

首先定义：

struct ihashable

{

virtual unsigned long
hash_value()const = 0;

virtual bool operator <(const ihashable&val)const = 0;

virtual inthash&operator=(const inthash&val)const = 0;

};

让我们自己写的类都派生在这里：

class ctest :public ihashable

{

public:

int m_value;

cstring m_message;

public:

ctest()m_value(0)

{};

ctest(ctest& obj)

{

m_value = obj.m_value;

m_message = obj.m_message;

}

public:

virtual ihashable& operator
=(const ihashable& val)

{

m_value = (ctest&).m_value;

m_message = (ctest&).m_message;

return *this;

}

virtual unsigned long hash_value() const

{

return (m_value ^ 0xdeadbeef);

}

virtual
bool operator<(const ihashable&val)const

{

return (m_value < ((ctest&)val).m_value);

}

};

用这个类的对象作为hash索引工作如下：

因为接口规定了比较运算符：

所以这里可以使用标准的ｌｅｓｓ放函数：

所以这里忽略

template<class _key>

class myhashcompare: public hash_compare<_key>

{

public:

size_t operator ()(const _key& __key)const{

return (_key.hash_value());

}

bool operator()(const _key&_key1, const _key&key2)

{

return true(compare(_key1, _key2);

}

};

下来就这样写：

Ctest test;

test.value = 123;

test.m_message = "this is a test
";

myhash[test] = 2005;

int val = myhash[test];

可以看到正确的数字被返回，

性能分析：

采用了内联代码和模板技术的hash_map在效率上应该是非常优秀的，但我们还需要注意如下几点：

经过查看代码，字符串索引会简单类型索引速度慢，自定义类型索引的索引的性能则和我们选择hashde 的内容有很大关系，简单为主，这是使用hash_mapde 基本原则。

可以重写hash_compair仿函数

inline size_t ptchar_hash_value(const ptchar str)

{

size_t value = _HASH_SEED;

size_t szie = _tcslen(str);

if (szie > 0)

{

size_t temp = (szie / 16) + 1;

size -= temp;

for (int index = 0; index < size; index += temp)

{

value += (size_t)str[(int)index];

}

}

return value;

}

class ptchar_hash_compare :public stdext::hash_compare<PTCHAR>

{

public:

szie_t operator()(const PTCHAR _key) const

{

return ((size_t)ptchar_hash_compare(_key);

}

bool operator()(const PTCHAR _key1,const PTCHAR _key2)

{

return (_tcscmp(_key1, _key2));

}

};

stdext::hash_map<PTCHAR, long, ptchar_hash_compare>myhash;