stl源码剖析 详细学习笔记 hashtable

//---------------------------15/03/24----------------------------

//hashtable
{

/*

概述：

sgi采用的是开链法完成hashtable的，也就是用链表来存储映射到相同位置的元素。

*/



//node（节点）

template<class Value>

struct __hashtable_node
{
__hashtable_node* next;
Value val;
};

//bucket维护的linked list不是stl的list或slist，而是自行维护的，table则是用vector完成以便扩充





//迭代器

template<class Value,
class Key, class HashFcn,
class ExtractKey,

class EqualKey, class Alloc>

struct __hashtable_iterator
{

typedef hashtable<Value, Key, HashFcn, ExtractKey, EqualKey, Alloc>
hashtable;

typedef __hashtable_iterator<Value, Key, HashFcn, ExtractKey,
EqualKey, Alloc>
iterator;

typedef __hashtable_const_iterator<Value, Key, HashFcn, ExtractKey,
EqualKey, Alloc>
const_iterator;

typedef __hashtable_node<Value> node;



typedef forward_iterator_tag iterator_category;

typedef Value value_type;

typedef ptrdiff_t difference_type;

typedef size_t size_type;

typedef Value& reference;

typedef Value* pointer;


node* cur;
hashtable* ht;


__hashtable_iterator(node* n, hashtable* tab): cur(n), ht(tab){}
__hashtable_iterator(){}
reference
operator*() const {return cur->val;}
pointer
operator->() const {return &(operator*());}
iterator&
operator++();
iterator
operator++(int);

bool operator==(const iterator& it)
const {return cur == it.cur;}

bool operator!=(const iterator& it)
const {return cur != it.cur;}


};





//operator++()



template<class V,
class K, class HF,
class ExK, class EqK,
class A>
__hashtable_iterator<V, K, HF, ExK, EqK, A>&
__hashtable_iterator<V, K, HF, ExK, EqK, A>::operator++()
{

const node* old = cur;

//cur是当前节点，用->next取得下个节点，如果这个位置已经没有更多节点，cur就是null
cur = cur->next;

if(!cur)
{

//如果没有更多节点，使用val取得之前的cur在table中的位置
size_type bucket = ht->bkt_num(old->val);

//只要cur为null
并且 下一个位置小于最大值
就让cur为下一个位置的节点(如果存在就有值，不然为null)

while(!cur && ++bucket < ht->buckets.size())
cur = ht->buckets[bucket];
}

//如果++没有找到下一个元素(之后没有元素了)，cur就为ht->buckets[buckets.size()-1]==null

//返回的iterator指向null，否则指向下一个节点

return *this;
}



template<class V,
class K, class HF,
class ExK, class EqK,
class A>
__hashtable_iterator<V, K, HF, ExK, EqK, A>&
__hashtable_iterator<V, K, HF, ExK, EqK, A>::operator++(int)
{
iterator tmp = *this;
++*this;

return tmp;
}



//没有--操作





//class声明式

template<class Value,
class Key, class HashFcn,
class ExtractKey,

class EqualKey, class Alloc=alloc>

class hashtable;



//class定义

//Value:节点的实值类型 Key：节点的键值类型 HashFcn：hash function的函数类型

//ExtractKey:
从节点中取出键值的方法(可以使函数或仿函数) EqualKey:判断键值相同与否的方法(函数或仿函数)

template<class Value,
class Key, class HashFcn,
class ExtractKey,

class EqualKey, class Alloc>

class hashtable
{

public:

typedef HashFcn hasher;

typedef EqualKey key_equel;

typedef size_t size_type;



private:
hasher hash;
key_equel equals;
ExtractKey get_key;



typedef __hashtable_node<Value> node;

typedef simple_alloc<node, Alloc> node_allocator;


vector<node*, Alloc> buckets;
size_type num_elements;



public:
size_type bucket_count()
const {return buckets.size();}






};



//虽然开链法不要求表格大小必须为质数，但是sgi stl还是用质数大小来设计表格(这样碰撞的机会会变小)

//而且先把28个质数计算好，以备随时访问，同时提供一个函数来查询最适合的质数



static const
int __stl_num_primes =
28;

static const
unsigned long __stl_prime_list[__stl_num_primes]=
{

53,
97, 193...
4294967291ul
};



//获取大于n的下一个质数，不会超过last－1

inline
unsigned long __stl_next_prime(unsigned
long n)
{

const unsigned
long* first = __stl_prime_list;

const unsigned
long* last = __stl_prime_list + __stl_num_primes;

//使用全局算法lower_bound获取n的位置，把指针当迭代器来用

const unsigned
long* pos = lower_bound(first, last, n);



return pos ==last ?*(last -
1) : *pos;
}


size_type max_bucket_count()
const
{

return __stl_prime_list[__stl_num_primes -
1];
}





//构造与内存管理

template<class Value,
class Key, class HashFcn,
class ExtractKey,

class EqualKey, class Alloc>

class hashtable
{

typedef simple_alloc<node, Alloc> node_allocator;



//创建和销毁节点，和以前类型
node* new_node(const value_type& obj)
{
node* n =node_allocator::allocate();
n->next =
0;
__STL_TRY
{
construct(&n->val, obj);

return n;
}
__STL_UNWIND(node_allocator::deallocate(n));
}



void delete_node(node* n)
{
destroy(&n->val);
node_allocator::deallocate(n);
}



//构造函数，设置好hash函数，判断相等的函数，取得键值(键值是用来比较是否相等的)的函数

//根据n设置好table的大小
hashtable(size_type n,
const HashFcn& hf,
const EqualKey& eql)
:hash(hf), equals(eql), get_key(ExtractKey()), num_elements(0)
{
initialize_buckets(n);
}



//initialize_buckets

void initialize_buckets(size_type n)
{

//找到合适的质数

const size_type n_buckets = next_size(n);

//保留 n_buckets大小的空间
buckets.reserve(n_buckets);

//所有的空间初始化为0
buckets.insert(buckets.end(), n_buckets, (node*)0);
num_elements =
0;
}



//insert


pair<iterator,
bool> insert_unique(const value_type& obj)
{
resize(num_elements +
1);

return insert_unique_noresize(obj);
}


iterator insert_equal(const value_type& obj)
{
resize(num_elements +
1);

return insert_equal_noresize(obj);
}



//取得位置，首先要根据get_key函数
取得键值，只要针对非数值类型的变量

//比如字符串，string或者自定义类对象(对于这些我们要自己写好get_key函数传入模版参数)

//n表示取模的大小，最后要先调用hash函数，然后取模(默认就是table的大小)
size_type bkt_num(const value_type& obj, size_t n)
const
{

return bkt_num_key(get_key(obj), n);
}

//使用默认的取模大小
size_type bkt_num(const value_type& obj)
const
{

return bkt_num_key(get_key(obj));
}



//使用默认的取模大小
size_type bkt_num_key(const key_type& key)
const
{

return bkt_num_key(key, buckets.size());
}



//真正的取位置操作，根据传入的键值，先调用hash函数，然后取模
size_type bkt_num_key(const value_type& obj, size_t n)
const
{

return hash(key) % n;
}



//find
iterator find(const key_type& key)
{

//找到位置
size_type n = bkt_num_key(key);
node* first;

//在链表中查找是否存在
这个键值

for( first = buckets
;
first && !equals(get_key(first->val),key);
first = first->next)
{}

//不存在this就是null，会返回false，否则就是true

return iterator(first,
this);
}



//count
size_type count(const key_type& key)
const
{

//找到键值位置

const size_type n =bkt_num_key(key);
size_type result =
0;

//找到链表中和键值相等的元素个数

for(const node* cur = buckets
; cur; cur = cur->next)

if(equals(get_key(cur->val), key))
++result;

return result;
}


};



//resize

template<class V,
class K, class HF,
class Ex, class Eq,
class A>
__hashtable_iterator<V, K, HF, Ex, Eq, A>&
__hashtable_iterator<V, K, HF, Ex, Eq, A>::resize(size_type num_elements_hint)
{



//纪录原来table的大小

const size_type old_n = buckets.size();

if(num_elements_hint > old_n)
{

//如果新大小大于原来table大小

//找到下一个合适的质数

const size_type n = next_size(num_elements_hint);

if(n > old_n)
{

//这里如果之前n就是最后一个质数了，就不会进入这个块语句了

//初始化n大小的为0的vector
vector<node*, A> tmp(n, (node*)0);

for(size_type bucket =
0; bucket < old_n; ++bucket)
{

//从原来的table中一个个复制到新table中
node* first = buckets[bucket];

while(first)
{
size_type new_bucket = bkt_num(first->val, n);


buckets[bucket] = first->next;


first->next = tmp[new_bucket];
tmp[new_bucket] = first;
first = buckets[bucket];
}
}

//交换新的table为当前table
buckets.swap(tmp);
}
}
}



//insert_unique_noresize

template<class V,
class K, class HF,
class Ex, class Eq,
class A>
__hashtable_iterator<V, K, HF, Ex, Eq, A>&
__hashtable_iterator<V, K, HF, Ex, Eq, A>::insert_unique_noresize(const value_type& obj)
{

//插入操作不可重复

//找到位置

const size_type n =bkt_num(obj);

//第一个节点
node* first = buckets
;



//查找节点，如果有重复的键值，就返回false

for(node* cur = first; cir; cur = cur->next)

if(equals(get_key(cur->val), get_key(obj)))

return pair<iterator,
bool>(iterator(cur,this),false);



//插入新节点为第一个节点，从这看出，链表没有排序
node* tmp = new_node(obj);
tmp->next = first;
buckets
= tmp;
++num_elements;

return pair<iterator,
bool>(iterator(tmp, this),
true);
}



//insert_equal_noresize

template<class V,
class K, class HF,
class Ex, class Eq,
class A>
__hashtable_iterator<V, K, HF, Ex, Eq, A>&
__hashtable_iterator<V, K, HF, Ex, Eq, A>::insert_equal_noresize(const value_type& obj)
{

//可以插入相同键值的节点，如果有相同键值就插到原来键值的后面，否则成为第一个节点

const size_type n = bkt_num(obj);
node* first = buckets
;



for(node* cur = first; cur; cur = cur->next)

if(equals(get_key(cur->val), get_key(obj)))
{
node* tmp =new_node(obj);
tmp->next = cur->next;
cur->next = tmp;
++num_elements;

return iterator(tmp,
this);
}


node* tmp = new_node(obj);
tmp->next = first;
buckets
= tmp;
++num_elements;

return iterator(tmp,
this);
}



//clear

template<class V,
class K, class HF,
class Ex, class Eq,
class A>
__hashtable_iterator<V, K, HF, Ex, Eq, A>&
__hashtable_iterator<V, K, HF, Ex, Eq, A>::clear()
{

//从头部一个个删除节点

for(size_type i =
0; i < buckets.size(); ++i)
{
node* cur = buckets[i];

while(cur != 0)
{
node* next = cur->next;
delete_node(cur);
cur = next;
}
buckets[i] =
0;
}
num_elements =
0;
}





//copy_from

template<class V,
class K, class HF,
class Ex, class Eq,
class A>
__hashtable_iterator<V, K, HF, Ex, Eq, A>&
__hashtable_iterator<V, K, HF, Ex, Eq, A>::copy_from(const hashtable& ht)
{

//调用buckets.clear()
先清除原来的table，再插入要copy的各个节点

//疑惑：
为什么不先调用一次clear()，不这样
原来table中的节点不是都没释放么？

//不是会造成内存泄漏？
buckets.clear();
buckets.reserve(ht.buckets.size());


bucket.insert(buckets.end(), ht.buckets.size(), (node*)
0 );
__STL_TRY
{

for(size_type i =
0; i < ht.buckets.size(); ++i)
{

if(const node* cur = ht.buckets[i])
{
node* copy = new_node(cur->val);
bucket[i] = copy;



for(node* next = cur->next; next; cur =next, next = cur->next)
{
copy->next =new_node(next->val);
copy = copy->next;
}
}
}
num_elements = ht.num_elements;
}
__STL_UNWIND(clear());
}





template<class Key>

struct hash{};

//计算key值函数，计算char*类型的 key值：
h(n)=h(n-1)*5 + *s *s就是(*s)的ascii码值

//
这样计算就使得字符与其位置有关，如果少了h(n-1)*5 那么 asd
和dsa 就会计算得到相同的位置

inline size_t __stl_hash_string(const
char* s)
{

unsigned long h =
0;

for( ; *s; ++s)
h =
5*h + *s;



return size_t(h);
}



//模版特化

//仿函数:利用 __stl_hash_string
取得key值
__STL_TEMPLATE_NULL
struct hash<char*>
{
size_t
operator()(const
char* s) const {return __stl_hash_string(s);}
};



/*

总结：hashtable就是一个大小为质数的vector中存放一条链表，查找和存放都要利用hash函数取得

对应的位置，然后存放到链表中，hash函数可以自定义(自己针对自己的类型进行特化)，hashtable的hash

函数正确来说其实就是取模操作(默认操作)，上面说的hash函数只是给出一个键值(当然也可以在这里自定义hash函数，

比如加个质数什么的)，最后当然还是要取模运算。

最后就是copy_from里为什么没有调用clear()，这样应该会造成内存泄漏，当然很可能是我想错了，毕竟这是大牛

们写的
我也查过最新的sgi stl 上面还是这么写的。



*/
}