hash_map和hash_multimap

hash_map

 1 template <class Pair>
 2 struct Select1st
 3 {
 4     const typename Pair::first_type& operator()(const Pair& x) const
 5     {
 6         return x.first;
 7     }
 8 };
 9 template <typename Key, typename Tp, typename Hash = std::hash<Key>, typename Equal=std::equal_to<Key> >
10 class MyHashmap
11 {
12 private:
13     typedef MyHashtable<std::pair<const Key, Tp>, Key, Hash, 
14         Select1st<std::pair<const Key, Tp> >, Equal> HashTable;
15     HashTable m_hashtable;
16 
17 public:
18     typedef typename HashTable::key_type key_type;
19     typedef typename HashTable::value_type value_type;
20     typedef typename HashTable::reference reference;
21     typedef typename HashTable::iterator iterator;
22 
23 public:
24     MyHashmap() : m_hashtable(100) {}
25     explicit MyHashmap(size_t n) : m_hashtable(n) {}
26 
27 public:
28     size_t size() const { return m_hashtable.size(); }
29     bool empty() const { return m_hashtable.empty(); }
30     void swap(MyHashmap& hs) { m_hashtable.swap(hs.m_hashtable); }
31 
32     iterator begin() { return m_hashtable.begin(); }
33     iterator end() { return m_hashtable.end(); }
34 
35 public:
36     std::pair<iterator, bool> insert(const value_type& obj)
37     {
38         return m_hashtable.insert_unique(obj);
39     }
40     iterator find(const key_type& key) { return m_hashtable.find(key); }
41 
42     Tp& operator[](const key_type& key) 
43     {
44         return m_hashtable.find_or_insert(value_type(key, Tp())).second;
45     }
46 
47     size_t count(const key_type& key) const { return m_hashtable.count(key); }
48 
49     size_t erase(const key_type& key) { return m_hashtable.erase(key); }
50     void erase(iterator it) { m_hashtable.erase(it); }
51     void clear() { m_hashtable.clear(); }
52     void resize(size_t hint) { m_hashtable.resize(hint); }
53     size_t bucket_count() const { return m_hashtable.bucket_count(); }
54 };

hash_multimap

 1 template <typename Key, typename Tp, typename Hash = std::hash<Key>, typename Equal = std::equal_to<Key> >
 2 class MyHashMultimap
 3 {
 4 private:
 5     typedef MyHashtable<std::pair<const Key, Tp>, Key, Hash,
 6         Select1st<std::pair<const Key, Tp> >, Equal> HashTable;
 7     HashTable m_hashtable;
 8 public:
 9     typedef typename HashTable::key_type key_type;
10     typedef typename HashTable::value_type value_type;
11     typedef typename HashTable::reference reference;
12     typedef typename HashTable::iterator iterator;
13 public:
14     MyHashMultimap() : m_hashtable(100) {}
15     explicit MyHashMultimap(size_t n) : m_hashtable(n) {}
16 public:
17     size_t size() const { return m_hashtable.size(); }
18     size_t max_size() const { return m_hashtable.max_size(); }
19     bool empty() const { return m_hashtable.empty(); }
20     void swap(MyHashMultimap& hs) { m_hashtable.swap(hs.m_hashtable); }
21 
22     iterator begin() { return m_hashtable.begin(); }
23     iterator end() { return m_hashtable.end(); }
24 public:
25     iterator insert(const value_type& __obj)
26     {
27         return m_hashtable.insert_equal(__obj);
28     }
29     iterator find(const key_type& key) { return m_hashtable.find(key); }
30     size_t count(const key_type& key) const { return m_hashtable.count(key); }
31     size_t erase(const key_type& key) { return m_hashtable.erase(key); }
32     void erase(iterator it) { m_hashtable.erase(it); }
33     void clear() { m_hashtable.clear(); }
34 
35 public:
36     void resize(size_t __hint) { m_hashtable.resize(__hint); }
37     size_t bucket_count() const { return m_hashtable.bucket_count(); }
38 };

 

template <typename Key, typename Tp, typename Hash = std::hash<Key>, typename Equal = std::equal_to<Key> >class MyHashMultimap{private:typedef MyHashtable<std::pair<const Key, Tp>, Key, Hash,Select1st<std::pair<const Key, Tp> >, Equal> HashTable;HashTable m_hashtable;public:typedef typename HashTable::key_type key_type;typedef typename HashTable::value_type value_type;typedef typename HashTable::reference reference;typedef typename HashTable::iterator iterator;public:MyHashMultimap() : m_hashtable(100) {}explicit MyHashMultimap(size_t n) : m_hashtable(n) {}public:size_t size() const { return m_hashtable.size(); }size_t max_size() const { return m_hashtable.max_size(); }bool empty() const { return m_hashtable.empty(); }void swap(MyHashMultimap& hs) { m_hashtable.swap(hs.m_hashtable); }
iterator begin() { return m_hashtable.begin(); }iterator end() { return m_hashtable.end(); }public:iterator insert(const value_type& __obj){return m_hashtable.insert_equal(__obj);}iterator find(const key_type& key) { return m_hashtable.find(key); }size_t count(const key_type& key) const { return m_hashtable.count(key); }size_t erase(const key_type& key) { return m_hashtable.erase(key); }void erase(iterator it) { m_hashtable.erase(it); }void clear() { m_hashtable.clear(); }
public:void resize(size_t __hint) { m_hashtable.resize(__hint); }size_t bucket_count() const { return m_hashtable.bucket_count(); }};

posted @ 2021-02-25 20:42  ho966  阅读(142)  评论(0)  编辑  收藏  举报