From Jason Turner

[multimap.overview]

C++11 → C++14 3.7 KB 37 lines
Current Draft | LaTeX Source
Archived: C++11 | C++14
Markdown: C++11 | C++14
Explore in Adventure Game
C++ Weekly: Ep 193

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmpuv5pralw/{from.md → to.md} +25 -8
tmp/tmpuv5pralw/{from.md → to.md} RENAMED
@@ -53,29 +53,33 @@ namespace std {
53
  return comp(x.first, y.first);
54
  }
55
  };
56
 
57
  // construct/copy/destroy:
58
- explicit multimap(const Compare& comp = Compare(),
 
59
  const Allocator& = Allocator());
60
  template <class InputIterator>
61
  multimap(InputIterator first, InputIterator last,
62
  const Compare& comp = Compare(),
63
  const Allocator& = Allocator());
64
- multimap(const multimap<Key,T,Compare,Allocator>& x);
65
- multimap(multimap<Key,T,Compare,Allocator>&& x);
66
  explicit multimap(const Allocator&);
67
  multimap(const multimap&, const Allocator&);
68
  multimap(multimap&&, const Allocator&);
69
  multimap(initializer_list<value_type>,
70
  const Compare& = Compare(),
71
  const Allocator& = Allocator());
 
 
 
 
 
72
  ~multimap();
73
- multimap<Key,T,Compare,Allocator>&
74
- operator=(const multimap<Key,T,Compare,Allocator>& x);
75
- multimap<Key,T,Compare,Allocator>&
76
- operator=(multimap<Key,T,Compare,Allocator>&& x);
77
  multimap& operator=(initializer_list<value_type>);
78
  allocator_type get_allocator() const noexcept;
79
 
80
  // iterators:
81
  iterator begin() noexcept;
@@ -110,31 +114,44 @@ namespace std {
110
  void insert(initializer_list<value_type>);
111
 
112
  iterator erase(const_iterator position);
113
  size_type erase(const key_type& x);
114
  iterator erase(const_iterator first, const_iterator last);
115
- void swap(multimap<Key,T,Compare,Allocator>&);
116
  void clear() noexcept;
117
 
118
  // observers:
119
  key_compare key_comp() const;
120
  value_compare value_comp() const;
121
 
122
  // map operations:
123
  iterator find(const key_type& x);
124
  const_iterator find(const key_type& x) const;
 
 
 
125
  size_type count(const key_type& x) const;
 
126
 
127
  iterator lower_bound(const key_type& x);
128
  const_iterator lower_bound(const key_type& x) const;
 
 
 
129
  iterator upper_bound(const key_type& x);
130
  const_iterator upper_bound(const key_type& x) const;
 
 
131
 
132
  pair<iterator,iterator>
133
  equal_range(const key_type& x);
134
  pair<const_iterator,const_iterator>
135
  equal_range(const key_type& x) const;
 
 
 
 
136
  };
137
 
138
  template <class Key, class T, class Compare, class Allocator>
139
  bool operator==(const multimap<Key,T,Compare,Allocator>& x,
140
  const multimap<Key,T,Compare,Allocator>& y);
 
53
  return comp(x.first, y.first);
54
  }
55
  };
56
 
57
  // construct/copy/destroy:
58
+ multimap() : multimap(Compare()) { }
59
+ explicit multimap(const Compare& comp,
60
  const Allocator& = Allocator());
61
  template <class InputIterator>
62
  multimap(InputIterator first, InputIterator last,
63
  const Compare& comp = Compare(),
64
  const Allocator& = Allocator());
65
+ multimap(const multimap& x);
66
+ multimap(multimap&& x);
67
  explicit multimap(const Allocator&);
68
  multimap(const multimap&, const Allocator&);
69
  multimap(multimap&&, const Allocator&);
70
  multimap(initializer_list<value_type>,
71
  const Compare& = Compare(),
72
  const Allocator& = Allocator());
73
+ template <class InputIterator>
74
+ multimap(InputIterator first, InputIterator last, const Allocator& a)
75
+ : multimap(first, last, Compare(), a) { }
76
+ multimap(initializer_list<value_type> il, const Allocator& a)
77
+ : multimap(il, Compare(), a) { }
78
  ~multimap();
79
+ multimap& operator=(const multimap& x);
80
+ multimap& operator=(multimap&& x);
 
 
81
  multimap& operator=(initializer_list<value_type>);
82
  allocator_type get_allocator() const noexcept;
83
 
84
  // iterators:
85
  iterator begin() noexcept;
 
114
  void insert(initializer_list<value_type>);
115
 
116
  iterator erase(const_iterator position);
117
  size_type erase(const key_type& x);
118
  iterator erase(const_iterator first, const_iterator last);
119
+ void swap(multimap&);
120
  void clear() noexcept;
121
 
122
  // observers:
123
  key_compare key_comp() const;
124
  value_compare value_comp() const;
125
 
126
  // map operations:
127
  iterator find(const key_type& x);
128
  const_iterator find(const key_type& x) const;
129
+ template <class K> iterator find(const K& x);
130
+ template <class K> const_iterator find(const K& x) const;
131
+
132
  size_type count(const key_type& x) const;
133
+ template <class K> size_type count(const K& x) const;
134
 
135
  iterator lower_bound(const key_type& x);
136
  const_iterator lower_bound(const key_type& x) const;
137
+ template <class K> iterator lower_bound(const K& x);
138
+ template <class K> const_iterator lower_bound(const K& x) const;
139
+
140
  iterator upper_bound(const key_type& x);
141
  const_iterator upper_bound(const key_type& x) const;
142
+ template <class K> iterator upper_bound(const K& x);
143
+ template <class K> const_iterator upper_bound(const K& x) const;
144
 
145
  pair<iterator,iterator>
146
  equal_range(const key_type& x);
147
  pair<const_iterator,const_iterator>
148
  equal_range(const key_type& x) const;
149
+ template <class K>
150
+ pair<iterator, iterator> equal_range(const K& x);
151
+ template <class K>
152
+ pair<const_iterator, const_iterator> equal_range(const K& x) const;
153
  };
154
 
155
  template <class Key, class T, class Compare, class Allocator>
156
  bool operator==(const multimap<Key,T,Compare,Allocator>& x,
157
  const multimap<Key,T,Compare,Allocator>& y);