From Jason Turner

[unord.multiset.overview]

C++11 → C++14 4.8 KB 46 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/tmp78adawpi/{from.md → to.md} +29 -12
tmp/tmp78adawpi/{from.md → to.md} RENAMED
@@ -33,24 +33,25 @@ namespace std {
33
  typedef Key key_type;
34
  typedef Key value_type;
35
  typedef Hash hasher;
36
  typedef Pred key_equal;
37
  typedef Allocator allocator_type;
38
- typedef typename allocator_type::pointer pointer;
39
- typedef typename allocator_type::const_pointer const_pointer;
40
- typedef typename allocator_type::reference reference;
41
- typedef typename allocator_type::const_reference const_reference;
42
  typedef implementation-defined size_type;
43
  typedef implementation-defined difference_type;
44
 
45
  typedef implementation-defined iterator;
46
  typedef implementation-defined const_iterator;
47
  typedef implementation-defined local_iterator;
48
  typedef implementation-defined const_local_iterator;
49
 
50
  // construct/destroy/copy
51
- explicit unordered_multiset(size_type n = see below,
 
52
  const hasher& hf = hasher(),
53
  const key_equal& eql = key_equal(),
54
  const allocator_type& a = allocator_type());
55
  template <class InputIterator>
56
  unordered_multiset(InputIterator f, InputIterator l,
@@ -66,13 +67,29 @@ namespace std {
66
  unordered_multiset(initializer_list<value_type>,
67
  size_type = see below,
68
  const hasher& hf = hasher(),
69
  const key_equal& eql = key_equal(),
70
  const allocator_type& a = allocator_type());
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
71
  ~unordered_multiset();
72
  unordered_multiset& operator=(const unordered_multiset&);
73
- unordered_multiset operator=(unordered_multiset&&);
74
  unordered_multiset& operator=(initializer_list<value_type>);
75
  allocator_type get_allocator() const noexcept;
76
 
77
  // size and capacity
78
  bool empty() const noexcept;
@@ -136,14 +153,14 @@ namespace std {
136
  };
137
 
138
  template <class Key, class Hash, class Pred, class Alloc>
139
  void swap(unordered_multiset<Key, Hash, Pred, Alloc>& x,
140
  unordered_multiset<Key, Hash, Pred, Alloc>& y);
141
- template <class Key, class T, class Hash, class Pred, class Alloc>
142
- bool operator==(const unordered_multiset<Key, T, Hash, Pred, Alloc>& a,
143
- const unordered_multiset<Key, T, Hash, Pred, Alloc>& b);
144
- template <class Key, class T, class Hash, class Pred, class Alloc>
145
- bool operator!=(const unordered_multiset<Key, T, Hash, Pred, Alloc>& a,
146
- const unordered_multiset<Key, T, Hash, Pred, Alloc>& b);
147
  }
148
  ```
149
 
 
33
  typedef Key key_type;
34
  typedef Key value_type;
35
  typedef Hash hasher;
36
  typedef Pred key_equal;
37
  typedef Allocator allocator_type;
38
+ typedef typename allocator_traits<Allocator>::pointer pointer;
39
+ typedef typename allocator_traits<Allocator>::const_pointer const_pointer;
40
+ typedef value_type& reference;
41
+ typedef const value_type& const_reference;
42
  typedef implementation-defined size_type;
43
  typedef implementation-defined difference_type;
44
 
45
  typedef implementation-defined iterator;
46
  typedef implementation-defined const_iterator;
47
  typedef implementation-defined local_iterator;
48
  typedef implementation-defined const_local_iterator;
49
 
50
  // construct/destroy/copy
51
+ unordered_multiset();
52
+ explicit unordered_multiset(size_type n,
53
  const hasher& hf = hasher(),
54
  const key_equal& eql = key_equal(),
55
  const allocator_type& a = allocator_type());
56
  template <class InputIterator>
57
  unordered_multiset(InputIterator f, InputIterator l,
 
67
  unordered_multiset(initializer_list<value_type>,
68
  size_type = see below,
69
  const hasher& hf = hasher(),
70
  const key_equal& eql = key_equal(),
71
  const allocator_type& a = allocator_type());
72
+ unordered_multiset(size_type n, const allocator_type& a)
73
+ : unordered_multiset(n, hasher(), key_equal(), a) { }
74
+ unordered_multiset(size_type n, const hasher& hf, const allocator_type& a)
75
+ : unordered_multiset(n, hf, key_equal(), a) { }
76
+ template <class InputIterator>
77
+ unordered_multiset(InputIterator f, InputIterator l, size_type n, const allocator_type& a)
78
+ : unordered_multiset(f, l, n, hasher(), key_equal(), a) { }
79
+ template <class InputIterator>
80
+ unordered_multiset(InputIterator f, InputIterator l, size_type n, const hasher& hf,
81
+ const allocator_type& a)
82
+ : unordered_multiset(f, l, n, hf, key_equal(), a) { }
83
+ unordered_multiset(initializer_list<value_type> il, size_type n, const allocator_type& a)
84
+ : unordered_multiset(il, n, hasher(), key_equal(), a) { }
85
+ unordered_multiset(initializer_list<value_type> il, size_type n, const hasher& hf,
86
+ const allocator_type& a)
87
+ : unordered_multiset(il, n, hf, key_equal(), a) { }
88
  ~unordered_multiset();
89
  unordered_multiset& operator=(const unordered_multiset&);
90
+ unordered_multiset& operator=(unordered_multiset&&);
91
  unordered_multiset& operator=(initializer_list<value_type>);
92
  allocator_type get_allocator() const noexcept;
93
 
94
  // size and capacity
95
  bool empty() const noexcept;
 
153
  };
154
 
155
  template <class Key, class Hash, class Pred, class Alloc>
156
  void swap(unordered_multiset<Key, Hash, Pred, Alloc>& x,
157
  unordered_multiset<Key, Hash, Pred, Alloc>& y);
158
+ template <class Key, class Hash, class Pred, class Alloc>
159
+ bool operator==(const unordered_multiset<Key, Hash, Pred, Alloc>& a,
160
+ const unordered_multiset<Key, Hash, Pred, Alloc>& b);
161
+ template <class Key, class Hash, class Pred, class Alloc>
162
+ bool operator!=(const unordered_multiset<Key, Hash, Pred, Alloc>& a,
163
+ const unordered_multiset<Key, Hash, Pred, Alloc>& b);
164
  }
165
  ```
166