stl_hash_map.h

// Filename:    stl_hash_map.h

// Comment By:  凝霜

// E-mail:      mdl2009@vip.qq.com

// Blog:        http://blog.csdn.net/mdl13412

// hash_map和hash_multimap是对hashtable的简单包装, 很容易理解

/*

 * 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(, 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(, 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(, 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(, 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(, 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(, 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(, 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(, 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.h的更多相关文章

  1. C++ STL源码剖析

    stl_config.h defalloc.h stl_alloc.h memory.cpp stl_construct.h stl_uninitialized.h stl_iterator.h ty ...

  2. STL 之 hash_map源代码剖析

    // Filename: stl_hash_map.h // hash_map和hash_multimap是对hashtable的简单包装, 非常easy理解 /* * Copyright (c) 1 ...

  3. APUE中fcntl.h的使用及O_SYNC在Mac与Ubuntu下的测试

    此部分测试涉及到APUE V3中,第三章的图3-12到图3-14. 通过fcntl.h提供的功能,修改fd的文件属性,本处增加O_SYNC功能,并测试其效果. 本文涉及代码: tree ch3 ch3 ...

  4. 关于apue.3e中apue.h的使用

    关于apue.3e中apue.h的使用 近来要学一遍APUE第三版,并于此开博做为记录. 先下载源文件: # url: http://http//www.apuebook.com/code3e.htm ...

  5. YYModel 源码解读（二）之NSObject+YYModel.h (1)

    本篇文章主要介绍 _YYModelPropertyMeta 前边的内容 首先先解释一下前边的辅助函数和枚举变量,在写一个功能的时候,这些辅助的东西可能不是一开始就能想出来的,应该是在后续的编码过程中 ...

  6. YYModel 源码解读（一）之YYModel.h

    #if __has_include(<YYModel/YYModel.h>) FOUNDATION_EXPORT double YYModelVersionNumber; FOUNDATI ...

  7. error RC1015: cannot open include file 'afxres.h' 解决办法

    在为WindowsPhone8程序添加本地化的过程中遇到这个问题: 问题原因就是afxres.h文件缺失,下载它,放到VS安装目录下的VS\include目录下就可以了(选择目录的时候注意对应对版本) ...

  8. afxcomctl32.h与afxcomctl32.inl报错

    afxcomctl32.h与afxcomctl32.inl报错 编译公司一个几年前的老项目,是从VC6.0升级到VS2005的. 1.编译时报缺少头文件,于是附件包含目录,于是出现了以下报错: 1&g ...

  9. C标准头文件<math.h>

    定义域错误可以理解为超出了函数的适用范围,如果发生了定义域错误,设errno为EDOM 如果结果不能表示为double值,则发生值域错误,如果结果上溢,则函数返回HUGE_VAL的值,设errno为E ...

随机推荐

  1. python基础25 -----python高级用法

    一.Event 1.为什么会有Event? 线程的一个关键特性就是每个线程的运行都是独立运行且状态不可预测.如果程序中的线程需要通过别的线程的状态来判断自己线程中的 某个程序是否需要执行,那么Even ...

  2. javascript;Jquery;获取JSON对象，无刷新评论实例。

      <!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml"> <head> < ...

  3. 使用CoreData存储数据

    - (void)viewDidLoad { [super viewDidLoad]; //获取模型文件的路径 NSString *path=[[NSBundle mainBundle]pathForR ...

  4. linux eclipse的桌面快捷方式

    在桌面上创建一个eclipse.desktop [Desktop Entry] Encoding=UTF- Name=Eclipse Comment=Eclipse IDE Exec=/opt/Dev ...

  5. 【c++习题】【17/5/22】重载数组下标操作符

    一.写出程序运行结果 1#include <iostream > using namespace std; int a[10]={1,2, 3, 4, 5, 6, 7, 8, 9, 10} ...

  6. Mysql主从复制原理详解

    一.为什么要做主从同步 1.读写分离,降低对主数据库的IO消耗 2.避免数据丢失 3.提高业务系统性能 二.主从同步和集群的区别 1.主从同步 一般需要两台及以上数据库服务器即可(一台用于写入数据,一 ...

  7. centos7环境下zookeeper的搭建步骤之单机伪集群

    首先说明:这里是单机版的伪集群搭建 第一步:下载zookeeper:zookeeper的下载地址: http://mirror.bit.edu.cn/apache/zookeeper/ 第二步:安装: ...

  8. 20145240 《Java程序设计》第十周学习总结

    20145240 <Java程序设计>第十周学习总结 教材学习内容总结 网络编程 网络编程就是在两个或两个以上的设备(例如计算机)之间传输数据. 程序员所作的事情就是把数据发送到指定的位置 ...

  9. debug（实验）

    一.用到的简单的DOS命令: cd\ ——首先要用cd\ 退回到根目录C>下 dir ——显示文件列表 md hb ——建立hb子目录 cd hb ——进入hb子目录 copy d:\dos\m ...

  10. mongodb 中的Multikey Index Bounds解释$elemMatch

    首先说一下 $elemMatch的用法: { _id: 1, results: [ 82, 85, 88 ] } { _id: 2, results: [ 75, 88, 89 ] } $elemMa ...