vs 2003 中hash_map使用方法

vc 2003 中的hash_map与SGI STL中的定义有所不同，sgi stl中那个hash_map是根据hash值进行比较，但是VS 2003中的这个hash_map的定义是这样的：
template <
   class Key,
   class Type,
   class Traits=hash_compare<Key, less<Key> >,
   class Allocator=allocator<pair <const Key, Type> >
>
class hash_map；
这里有一个比较类型Traits，默认值为hash_compare<Key, less<Key> >模板类型。

一、Traits揭秘：

MSDN中对Traits的描述如下：
The type which includes two function objects, one of class compare able to compare two element values as sort keys to determine their relative order and a hash function that is a unary predicate mapping key values of the elements to unsigned integers of type size_t. This argument is optional, and hash_compare<Key, less<Key> > is the default value.

就是说Traits中要包含两个function，一个function能根据比较两个Key，决定其相对位置，另一个function能将Key映射为一个唯一的unsigned int值(即Key的hash value)。

The hash_map orders the sequence it controls by calling a stored hash Traits object of class value_compare. This stored object may be accessed by calling the member function key_comp. Such a function object must behave the same as an object of class hash_compare<Key, less<Key> >. Specifically, for all values _Key of type Key, the call Traits(_Key ) yields a distribution of values of type size_t.

结合Traits的默认值 hash_compare的实现，看一下：
template<class _Kty,
 class _Pr = std::less<_Kty> >
 class hash_compare
 { // traits class for hash containers
public:
 enum
  { // parameters for hash table
  bucket_size = 4, // 0 < bucket_size
  min_buckets = 8}; // min_buckets = 2 ^^ N, 0 < N

 hash_compare()
  : comp()
  { // construct with default comparator
  }

 hash_compare(_Pr _Pred)
  : comp(_Pred)
  { // construct with _Pred comparator
  }

 size_t operator()(const _Kty& _Keyval) const
  { // hash _Keyval to size_t value
  return ((size_t)hash_value(_Keyval));
  }
 bool operator()(const _Kty& _Keyval1, const _Kty& _Keyval2) const
  { // test if _Keyval1 ordered before _Keyval2
  return (comp(_Keyval1, _Keyval2));
  }

protected:
 _Pr comp; // the comparator object
 };

在hash_compare的实现中有两个重要函数：
size_t operator()(const _Kty& _Keyval) const
bool operator()(const _Kty& _Keyval1, const _Kty& _Keyval2) const
第一个即是对Key作hash运算，第二个是比较Key的大小。
在比较Key的函数中，使用了_Pr 类型的comp，_Pr的默认类型正是less<_Kty>

就是说即使我们定义了自己的Traits实现来代替hash_compare,也要定义相应的两个函数。
如在.net 2002中对string并没有定义相应的Traits,那么我们可以这样定义

using   namespace   std;  
class   string_hash  
{  
  public:  
  enum  
  { //   parameters   for   hash   table  
   bucket_size   =   4, //   0   <   bucket_size  
   min_buckets   =   8  
  }; //   min_buckets   =   2   ^^   N,   0   <   N  
   
  string_hash()   {}  
  size_t   operator()(const   string&   key)   const  
  {  
   long h = 0;  
   for(int i=0; i<key.size(); ++i)
 {  
  h += key[i];
  }  
   return (size_t)h;
  }  
   
  bool operator()(const string& key1, const string& key2) const
  {  
 return (key1.compare(key2) < 0);  
  }  
};  
Usage：   
  //this   is   just   a   simple   implementation   demonstrates   what   need   to   be   done   for   a    
  //hash   functor.   It's   not   optimized.  
  ....  
  hash_map<std::string,   int,   string_hash>   myMap;

二、使用自定义Key类型+默认的hash_compare

那么是不是当我们使用自定义的类型作Key时，就必须自己定义Traits呢？当然不是！怎样使用自定义类型Key时仍然使用默认的hash_compare呢？
在自定义Key类型中使用默认的hash_compare
我们可以看到
在函数 size_t operator()(const _Kty& _Keyval) const 的实现中，调用了hash_value(Key)，该函数返回一个size_t，
在函数 bool operator()(const _Kty& _Keyval1, const _Kty& _Keyval2) const 的实现中，调用了comp(Key& k1, Key& k2)
所以如果我们想要使用自定义Key类型,并且仍然采用hash_compare作为Traits的默认值，必须：
1、对自定义Key类型实现hash_value函数
2、重载operator <函数
3、hash_value函数和重载operator<函数都应属于namespace stdext中
如
class MyKeyType
{
........
}；
namespace stdext
{
size_t hash_value(MyKeyType & mykey)
{
......
}
bool operator <(MyKeyType &k1,MyKeyType &k2)
{
...
}
}

然后定义自己的hash_map: hash_map<MyKeyType, int> myMap;

三、替换hash_compare中的less<_Kty>
hash_compare默认采用了less<_Kty>作为其比较模板参数，我们可以把它替换成我们希望的比较模板，比如myGreater<_Kty>
在template less<class Type>中,重载了operator()函数，less定义如下：

template<class Type>
struct less
{ // functor for operator<
 bool operator()(const Type& _Left, const Type& _Right) const
 { // apply operator< to operands
  return (_Left < _Right);
 }
};

我们的myGreater可以如下定义：
template<class Type>
struct myGreater
{
public:
 bool operator()(const Type& _Left, const Type& _Right) const
 { // apply operator< to operands
  return (_Left > _Right);
 }
};
Usage:
 HashMap<MyKey, MyValue, stdext::hash_compare<MyKey,myGreater<MyKey> > > mHashMap;