// Filename:    stl_hash_map.h

// hash_map和hash_multimap是对hashtable的简单包装, 非常easy理解

/*

 * Copyright (c) 1996

 * Silicon Graphics Computer Systems, Inc.

 *

 * Permission to use, copy, modify, distribute and sell this software

 * and its documentation for any purpose is hereby granted without fee,

 * provided that the above copyright notice appear in all copies and

 * that both that copyright notice and this permission notice appear

 * in supporting documentation.  Silicon Graphics makes no

 * representations about the suitability of this software for any

 * purpose.  It is provided "as is" without express or implied warranty.

 *

 *

 * Copyright (c) 1994

 * Hewlett-Packard Company

 *

 * Permission to use, copy, modify, distribute and sell this software

 * and its documentation for any purpose is hereby granted without fee,

 * provided that the above copyright notice appear in all copies and

 * that both that copyright notice and this permission notice appear

 * in supporting documentation.  Hewlett-Packard Company makes no

 * representations about the suitability of this software for any

 * purpose.  It is provided "as is" without express or implied warranty.

 *

 */

/* NOTE: This is an internal header file, included by other STL headers.

 *   You should not attempt to use it directly.

 */

#ifndef __SGI_STL_INTERNAL_HASH_MAP_H

#define __SGI_STL_INTERNAL_HASH_MAP_H

__STL_BEGIN_NAMESPACE

#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)

#pragma set woff 1174

#endif

// 假设编译器不能依据前面模板參数推导出后面使用的默认參数类型,

// 那么就须要手工指定, 而且对于主要的数据类型, 在<stl_hash_fun.h>

// 中都提供hash函数

#ifndef __STL_LIMITED_DEFAULT_TEMPLATES

template <class Key, class T, class HashFcn = hash<Key>,

          class EqualKey = equal_to<Key>,

          class Alloc = alloc>

#else

template <class Key, class T, class HashFcn, class EqualKey,

          class Alloc = alloc>

#endif

class hash_map

{

private:

  typedef hashtable<pair<const Key, T>, Key, HashFcn,

                    select1st<pair<const Key, T> >, EqualKey, Alloc> ht;

  ht rep;

public:

  // 注意: reference, pointer, iterator都为const, 由于不能改动hashtable

  // 内部的元素, 否则会导致hashtable失效

  typedef typename ht::key_type key_type;

  typedef T data_type;

  typedef T mapped_type;

  typedef typename ht::value_type value_type;

  typedef typename ht::hasher hasher;

  typedef typename ht::key_equal key_equal;

  typedef typename ht::size_type size_type;

  typedef typename ht::difference_type difference_type;

  typedef typename ht::pointer pointer;

  typedef typename ht::const_pointer const_pointer;

  typedef typename ht::reference reference;

  typedef typename ht::const_reference const_reference;

  typedef typename ht::iterator iterator;

  typedef typename ht::const_iterator const_iterator;

  // 返回hash相关函数

  hasher hash_funct() const { return rep.hash_funct(); }

  key_equal key_eq() const { return rep.key_eq(); }

public:

  hash_map() : rep(100, hasher(), key_equal()) {}

  explicit hash_map(size_type n) : rep(n, hasher(), key_equal()) {}

  hash_map(size_type n, const hasher& hf) : rep(n, hf, key_equal()) {}

  hash_map(size_type n, const hasher& hf, const key_equal& eql)

    : rep(n, hf, eql) {}

#ifdef __STL_MEMBER_TEMPLATES

  template <class InputIterator>

  hash_map(InputIterator f, InputIterator l)

    : rep(100, hasher(), key_equal()) { rep.insert_unique(f, l); }

  template <class InputIterator>

  hash_map(InputIterator f, InputIterator l, size_type n)

    : rep(n, hasher(), key_equal()) { rep.insert_unique(f, l); }

  template <class InputIterator>

  hash_map(InputIterator f, InputIterator l, size_type n,

           const hasher& hf)

    : rep(n, hf, key_equal()) { rep.insert_unique(f, l); }

  template <class InputIterator>

  hash_map(InputIterator f, InputIterator l, size_type n,

           const hasher& hf, const key_equal& eql)

    : rep(n, hf, eql) { rep.insert_unique(f, l); }

#else

  hash_map(const value_type* f, const value_type* l)

    : rep(100, hasher(), key_equal()) { rep.insert_unique(f, l); }

  hash_map(const value_type* f, const value_type* l, size_type n)

    : rep(n, hasher(), key_equal()) { rep.insert_unique(f, l); }

  hash_map(const value_type* f, const value_type* l, size_type n,

           const hasher& hf)

    : rep(n, hf, key_equal()) { rep.insert_unique(f, l); }

  hash_map(const value_type* f, const value_type* l, size_type n,

           const hasher& hf, const key_equal& eql)

    : rep(n, hf, eql) { rep.insert_unique(f, l); }

  hash_map(const_iterator f, const_iterator l)

    : rep(100, hasher(), key_equal()) { rep.insert_unique(f, l); }

  hash_map(const_iterator f, const_iterator l, size_type n)

    : rep(n, hasher(), key_equal()) { rep.insert_unique(f, l); }

  hash_map(const_iterator f, const_iterator l, size_type n,

           const hasher& hf)

    : rep(n, hf, key_equal()) { rep.insert_unique(f, l); }

  hash_map(const_iterator f, const_iterator l, size_type n,

           const hasher& hf, const key_equal& eql)

    : rep(n, hf, eql) { rep.insert_unique(f, l); }

#endif /*__STL_MEMBER_TEMPLATES */

public:

  // 以下都是对hashtable的简单封装, 见<stl_hashtable.h>

  size_type size() const { return rep.size(); }

  size_type max_size() const { return rep.max_size(); }

  bool empty() const { return rep.empty(); }

  void swap(hash_map& hs) { rep.swap(hs.rep); }

  friend bool

  operator== __STL_NULL_TMPL_ARGS (const hash_map&, const hash_map&);

  iterator begin() { return rep.begin(); }

  iterator end() { return rep.end(); }

  const_iterator begin() const { return rep.begin(); }

  const_iterator end() const { return rep.end(); }

public:

  // 不同意插入key同样的元素

  pair<iterator, bool> insert(const value_type& obj)

    { return rep.insert_unique(obj); }

#ifdef __STL_MEMBER_TEMPLATES

  template <class InputIterator>

  void insert(InputIterator f, InputIterator l) { rep.insert_unique(f,l); }

#else

  void insert(const value_type* f, const value_type* l) {

    rep.insert_unique(f,l);

  }

  void insert(const_iterator f, const_iterator l) { rep.insert_unique(f, l); }

#endif /*__STL_MEMBER_TEMPLATES */

  pair<iterator, bool> insert_noresize(const value_type& obj)

    { return rep.insert_unique_noresize(obj); }

  iterator find(const key_type& key) { return rep.find(key); }

  const_iterator find(const key_type& key) const { return rep.find(key); }

  // 假设key存在则返回相应的元素, 否则新建一个key

  T& operator[](const key_type& key)

  {

    return rep.find_or_insert(value_type(key, T())).second;

  }

  // 以下封装见<stl_hashtable.h>

  size_type count(const key_type& key) const { return rep.count(key); }

  pair<iterator, iterator> equal_range(const key_type& key)

    { return rep.equal_range(key); }

  pair<const_iterator, const_iterator> equal_range(const key_type& key) const

    { return rep.equal_range(key); }

  size_type erase(const key_type& key) {return rep.erase(key); }

  void erase(iterator it) { rep.erase(it); }

  void erase(iterator f, iterator l) { rep.erase(f, l); }

  void clear() { rep.clear(); }

public:

  void resize(size_type hint) { rep.resize(hint); }

  size_type bucket_count() const { return rep.bucket_count(); }

  size_type max_bucket_count() const { return rep.max_bucket_count(); }

  size_type elems_in_bucket(size_type n) const

    { return rep.elems_in_bucket(n); }

};

template <class Key, class T, class HashFcn, class EqualKey, class Alloc>

inline bool operator==(const hash_map<Key, T, HashFcn, EqualKey, Alloc>& hm1,

                       const hash_map<Key, T, HashFcn, EqualKey, Alloc>& hm2)

{

  return hm1.rep == hm2.rep;

}

// 假设编译器支持模板函数特化优先级

// 那么将全局的swap实现为使用hash_map私有的swap以提高效率

#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER

template <class Key, class T, class HashFcn, class EqualKey, class Alloc>

inline void swap(hash_map<Key, T, HashFcn, EqualKey, Alloc>& hm1,

                 hash_map<Key, T, HashFcn, EqualKey, Alloc>& hm2)

{

  hm1.swap(hm2);

}

#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */

// hash_multimap和hash_map除去同意key反复外, 其余性质一致

#ifndef __STL_LIMITED_DEFAULT_TEMPLATES

template <class Key, class T, class HashFcn = hash<Key>,

          class EqualKey = equal_to<Key>,

          class Alloc = alloc>

#else

template <class Key, class T, class HashFcn, class EqualKey,

          class Alloc = alloc>

#endif

class hash_multimap

{

private:

  typedef hashtable<pair<const Key, T>, Key, HashFcn,

                    select1st<pair<const Key, T> >, EqualKey, Alloc> ht;

  ht rep;

public:

  typedef typename ht::key_type key_type;

  typedef T data_type;

  typedef T mapped_type;

  typedef typename ht::value_type value_type;

  typedef typename ht::hasher hasher;

  typedef typename ht::key_equal key_equal;

  typedef typename ht::size_type size_type;

  typedef typename ht::difference_type difference_type;

  typedef typename ht::pointer pointer;

  typedef typename ht::const_pointer const_pointer;

  typedef typename ht::reference reference;

  typedef typename ht::const_reference const_reference;

  typedef typename ht::iterator iterator;

  typedef typename ht::const_iterator const_iterator;

  hasher hash_funct() const { return rep.hash_funct(); }

  key_equal key_eq() const { return rep.key_eq(); }

public:

  hash_multimap() : rep(100, hasher(), key_equal()) {}

  explicit hash_multimap(size_type n) : rep(n, hasher(), key_equal()) {}

  hash_multimap(size_type n, const hasher& hf) : rep(n, hf, key_equal()) {}

  hash_multimap(size_type n, const hasher& hf, const key_equal& eql)

    : rep(n, hf, eql) {}

#ifdef __STL_MEMBER_TEMPLATES

  template <class InputIterator>

  hash_multimap(InputIterator f, InputIterator l)

    : rep(100, hasher(), key_equal()) { rep.insert_equal(f, l); }

  template <class InputIterator>

  hash_multimap(InputIterator f, InputIterator l, size_type n)

    : rep(n, hasher(), key_equal()) { rep.insert_equal(f, l); }

  template <class InputIterator>

  hash_multimap(InputIterator f, InputIterator l, size_type n,

                const hasher& hf)

    : rep(n, hf, key_equal()) { rep.insert_equal(f, l); }

  template <class InputIterator>

  hash_multimap(InputIterator f, InputIterator l, size_type n,

                const hasher& hf, const key_equal& eql)

    : rep(n, hf, eql) { rep.insert_equal(f, l); }

#else

  hash_multimap(const value_type* f, const value_type* l)

    : rep(100, hasher(), key_equal()) { rep.insert_equal(f, l); }

  hash_multimap(const value_type* f, const value_type* l, size_type n)

    : rep(n, hasher(), key_equal()) { rep.insert_equal(f, l); }

  hash_multimap(const value_type* f, const value_type* l, size_type n,

                const hasher& hf)

    : rep(n, hf, key_equal()) { rep.insert_equal(f, l); }

  hash_multimap(const value_type* f, const value_type* l, size_type n,

                const hasher& hf, const key_equal& eql)

    : rep(n, hf, eql) { rep.insert_equal(f, l); }

  hash_multimap(const_iterator f, const_iterator l)

    : rep(100, hasher(), key_equal()) { rep.insert_equal(f, l); }

  hash_multimap(const_iterator f, const_iterator l, size_type n)

    : rep(n, hasher(), key_equal()) { rep.insert_equal(f, l); }

  hash_multimap(const_iterator f, const_iterator l, size_type n,

                const hasher& hf)

    : rep(n, hf, key_equal()) { rep.insert_equal(f, l); }

  hash_multimap(const_iterator f, const_iterator l, size_type n,

                const hasher& hf, const key_equal& eql)

    : rep(n, hf, eql) { rep.insert_equal(f, l); }

#endif /*__STL_MEMBER_TEMPLATES */

public:

  size_type size() const { return rep.size(); }

  size_type max_size() const { return rep.max_size(); }

  bool empty() const { return rep.empty(); }

  void swap(hash_multimap& hs) { rep.swap(hs.rep); }

  friend bool

  operator== __STL_NULL_TMPL_ARGS (const hash_multimap&, const hash_multimap&);

  iterator begin() { return rep.begin(); }

  iterator end() { return rep.end(); }

  const_iterator begin() const { return rep.begin(); }

  const_iterator end() const { return rep.end(); }

public:

  iterator insert(const value_type& obj) { return rep.insert_equal(obj); }

#ifdef __STL_MEMBER_TEMPLATES

  template <class InputIterator>

  void insert(InputIterator f, InputIterator l) { rep.insert_equal(f,l); }

#else

  void insert(const value_type* f, const value_type* l) {

    rep.insert_equal(f,l);

  }

  void insert(const_iterator f, const_iterator l) { rep.insert_equal(f, l); }

#endif /*__STL_MEMBER_TEMPLATES */

  iterator insert_noresize(const value_type& obj)

    { return rep.insert_equal_noresize(obj); }

  iterator find(const key_type& key) { return rep.find(key); }

  const_iterator find(const key_type& key) const { return rep.find(key); }

  size_type count(const key_type& key) const { return rep.count(key); }

  pair<iterator, iterator> equal_range(const key_type& key)

    { return rep.equal_range(key); }

  pair<const_iterator, const_iterator> equal_range(const key_type& key) const

    { return rep.equal_range(key); }

  size_type erase(const key_type& key) {return rep.erase(key); }

  void erase(iterator it) { rep.erase(it); }

  void erase(iterator f, iterator l) { rep.erase(f, l); }

  void clear() { rep.clear(); }

public:

  void resize(size_type hint) { rep.resize(hint); }

  size_type bucket_count() const { return rep.bucket_count(); }

  size_type max_bucket_count() const { return rep.max_bucket_count(); }

  size_type elems_in_bucket(size_type n) const

    { return rep.elems_in_bucket(n); }

};

template <class Key, class T, class HF, class EqKey, class Alloc>

inline bool operator==(const hash_multimap<Key, T, HF, EqKey, Alloc>& hm1,

                       const hash_multimap<Key, T, HF, EqKey, Alloc>& hm2)

{

  return hm1.rep == hm2.rep;

}

#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER

template <class Key, class T, class HashFcn, class EqualKey, class Alloc>

inline void swap(hash_multimap<Key, T, HashFcn, EqualKey, Alloc>& hm1,

                 hash_multimap<Key, T, HashFcn, EqualKey, Alloc>& hm2)

{

  hm1.swap(hm2);

}

#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */

#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)

#pragma reset woff 1174

#endif

__STL_END_NAMESPACE

#endif /* __SGI_STL_INTERNAL_HASH_MAP_H */

// Local Variables:

// mode:C++

// End:

STL 之 hash_map源代码剖析的更多相关文章

  1. STL之hashtable源代码剖析

    // Filename: stl_hashtable.h /////////////////////////////////////////////////////////////////////// ...

  2. STL源代码剖析 读书总结

    <<STL源代码剖析>> 侯捷著 非常早就买了这本书, 一直没看, 如今在实验室师兄代码的时候发现里面使用了大量泛型编程的内容, 让我有了先看看这本书的想法. 看之前我对于泛型 ...

  3. STL源代码剖析(一) - 内存分配

    Allocaor allocator 指的是空间配置器,用于分配内存.STL中默认使用SGI STL alloc作为STL的内存分配器,尽管未能符合标准规格,但效率上更好.SGI STL也定义有一个符 ...

  4. STL源代码剖析——STL算法stl_algo.h

    前言 在前面的博文中剖析了STL的数值算法.基本算法和set集合算法.本文剖析STL其它的算法,比如排序算法.合并算法.查找算法等等.在剖析的时候.会针对函数给出一些样例说明函数的使用.源代码出自SG ...

  5. STL源代码剖析——基本算法stl_algobase.h

    前言 在STL中.算法是常常被使用的,算法在整个STL中起到很关键的数据.本节介绍的是一些基本算法,包括equal.fill.fill_n,iter_swap.lexicographical_comp ...

  6. 《STL源代码剖析》---stl_deque.h阅读笔记(2)

    看完,<STL源代码剖析>---stl_deque.h阅读笔记(1)后.再看代码: G++ 2.91.57,cygnus\cygwin-b20\include\g++\stl_deque. ...

  7. STL源代码剖析——STL算法之set集合算法

    前言 本节介绍set集合的相关算法,各自是并集set_union,差集set_difference,交集set_intersection 和对称差集set_symmetric_difference.这 ...

  8. STL源代码剖析(二) - 迭代器与traits技法

    提要 先看一段用迭代器的代码: int a[] = {1, 2, 3, 4, 5}; vector<int> v1( a, a+5); vector<int>::iterato ...

  9. 菜鸟nginx源代码剖析数据结构篇（一）动态数组ngx_array_t

    菜鸟nginx源代码剖析数据结构篇(一)动态数组ngx_array_t Author:Echo Chen(陈斌) Email:chenb19870707@gmail.com Blog:Blog.csd ...

随机推荐

  1. Maven缺少jar添加方式

    Maven 中央仓库地址: 1. http://www.sonatype.org/nexus/ 2. http://mvnrepository.com/ (本人推荐仓库) 3. http://repo ...

  2. luogu P4137 Rmq Problem / mex(可持久化线段树）

    一开始想的是莫队,然后维护几个bitset,然后瞎搞.脑子里想了想实现,发现并不好写. 还是主席树好写.我们维护一个权值的线段树,记录每一个权值的最后一次出现的位置下标.我们查询的时候要在前\(r\) ...

  3. CF939F Cutlet (单调队列优化DP)

    题目大意:要煎一块有两个面的肉,只能在一段k不相交的时间段$[l_{i},r_{i}]$内翻转,求$2*n$秒后,保证两个面煎的时间一样长时,需要最少的翻转次数,$n<=100000$,$k&l ...

  4. java list序列化json 对象、json数组

    list<T> 序列化   json对象   ----------- JSONObject -------JSONObject.toJSONString(str);  解析:JSONObj ...

  5. 紫书 习题8-12 UVa 1153（贪心）

    本来以为这道题是考不相交区间, 结果还专门复习了一遍前面写的, 然后发现这道题的区间是不是 固定的, 是在一个范围内"滑动的", 只要右端点不超过截止时间就ok. 然后我就先考虑有 ...

  6. 12个Unity5中优化VR 应用的技巧

    本文章由cartzhang编写,转载请注明出处. 所有权利保留. 文章链接:http://blog.csdn.net/cartzhang/article/details/50176429 作者:car ...

  7. 2018秋寒假作业4——PTA编辑总结1

    #include<stdio.h> #include<math.h> int main(void) { int n,i,j,p,m,ge,N,k; char op; ){ sc ...

  8. unity Android在streamingAssets路径下文件无法读取的的解决方法

    unity Android在streamingAssets路径下文件,有时候plugin下的.jar或者.so无法直接读取: 解决方法之一,拷贝至其他路径: #if UNITY_ANDROID str ...

  9. Scala学习笔记及与Java不同之处总结-从Java开发者角度

    Scala与Java具有很多相似之处,但又有很多不同.这里主要从一个Java开发者的角度,总结在使用Scala的过程中所面临的一些思维转变. 这里仅仅是总结了部分两种语言在开发过程中的不同,以后会陆续 ...

  10. 编写SDR SDRAM页突发模式控制器的注意点

    网上有很多的SDR SDRAM控制器的代码,但都是基于burst1/2/4/8模式下的,这种模式下传输高速的相机数据还是有点拮据的,所以花了几天把这些模式改造成了页突发模式.我的这个控制器模型是这样的 ...