typedef /unspecified/ iterator;
typedef /unspecified/ const_iterator;
- explicit hash_map(size_type n = 193, const hasher& hf = hasher(),
+ hash_map();
+ explicit hash_map(size_type n, const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& a = allocator_type());
template <class InputIterator>
- hash_map(InputIterator f, InputIterator l,
- size_type n = 193, const hasher& hf = hasher(),
- const key_equal& eql = key_equal(),
- const allocator_type& a = allocator_type());
+ hash_map(InputIterator f, InputIterator l);
+ template <class InputIterator>
+ hash_map(InputIterator f, InputIterator l,
+ size_type n, const hasher& hf = hasher(),
+ const key_equal& eql = key_equal(),
+ const allocator_type& a = allocator_type());
hash_map(const hash_map&);
~hash_map();
hash_map& operator=(const hash_map&);
typedef __hash_map_iterator<typename __table::iterator> iterator;
typedef __hash_map_const_iterator<typename __table::const_iterator> const_iterator;
- _LIBCPP_INLINE_VISIBILITY hash_map() {__table_.rehash(193);}
+ _LIBCPP_INLINE_VISIBILITY hash_map() { }
explicit hash_map(size_type __n, const hasher& __hf = hasher(),
const key_equal& __eql = key_equal());
hash_map(size_type __n, const hasher& __hf,
hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::hash_map(
_InputIterator __first, _InputIterator __last)
{
- __table_.rehash(193);
insert(__first, __last);
}
typedef __hash_map_const_iterator<typename __table::const_iterator> const_iterator;
_LIBCPP_INLINE_VISIBILITY
- hash_multimap() {__table_.rehash(193);}
+ hash_multimap() { }
explicit hash_multimap(size_type __n, const hasher& __hf = hasher(),
const key_equal& __eql = key_equal());
hash_multimap(size_type __n, const hasher& __hf,
hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::hash_multimap(
_InputIterator __first, _InputIterator __last)
{
- __table_.rehash(193);
insert(__first, __last);
}
typedef typename __table::const_iterator const_iterator;
_LIBCPP_INLINE_VISIBILITY
- hash_set() {__table_.rehash(193);}
+ hash_set() { }
explicit hash_set(size_type __n, const hasher& __hf = hasher(),
const key_equal& __eql = key_equal());
hash_set(size_type __n, const hasher& __hf, const key_equal& __eql,
hash_set<_Value, _Hash, _Pred, _Alloc>::hash_set(
_InputIterator __first, _InputIterator __last)
{
- __table_.rehash(193);
insert(__first, __last);
}
typedef typename __table::const_iterator const_iterator;
_LIBCPP_INLINE_VISIBILITY
- hash_multiset() {__table_.rehash(193);}
+ hash_multiset() { }
explicit hash_multiset(size_type __n, const hasher& __hf = hasher(),
const key_equal& __eql = key_equal());
hash_multiset(size_type __n, const hasher& __hf,
hash_multiset<_Value, _Hash, _Pred, _Alloc>::hash_multiset(
_InputIterator __first, _InputIterator __last)
{
- __table_.rehash(193);
insert(__first, __last);
}
//
//===----------------------------------------------------------------------===//
+
// Prevent emission of the deprecated warning.
#ifdef __clang__
#pragma clang diagnostic ignored "-W#warnings"
#endif
-// Poison the std:: names we might use inside __gnu_cxx to ensure they're
-// properly qualified.
-struct allocator;
-struct pair;
-struct equal_to;
-struct unique_ptr;
#include <ext/hash_map>
+#include <cassert>
#include "test_macros.h"
+#include "count_new.hpp"
-
-namespace __gnu_cxx {
-template class hash_map<int, int>;
+void test_default_does_not_allocate() {
+ DisableAllocationGuard g;
+ ((void)g);
+ {
+ __gnu_cxx::hash_map<int, int> h;
+ assert(h.bucket_count() == 0);
+ }
+ {
+ __gnu_cxx::hash_multimap<int, int> h;
+ assert(h.bucket_count() == 0);
+ }
}
int main(int, char**) {
- typedef __gnu_cxx::hash_map<int, int> Map;
- Map m;
- Map m2(m);
- ((void)m2);
-
- return 0;
+ test_default_does_not_allocate();
}
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// Prevent emission of the deprecated warning.
+#ifdef __clang__
+#pragma clang diagnostic ignored "-W#warnings"
+#endif
+
+// Poison the std:: names we might use inside __gnu_cxx to ensure they're
+// properly qualified.
+struct allocator;
+struct pair;
+struct equal_to;
+struct unique_ptr;
+#include <ext/hash_map>
+
+#include "test_macros.h"
+
+
+namespace __gnu_cxx {
+template class hash_map<int, int>;
+}
+
+int main(int, char**) {
+ typedef __gnu_cxx::hash_map<int, int> Map;
+ Map m;
+ Map m2(m);
+ ((void)m2);
+
+ return 0;
+}
//
//===----------------------------------------------------------------------===//
+
// Prevent emission of the deprecated warning.
#ifdef __clang__
#pragma clang diagnostic ignored "-W#warnings"
#endif
-// Poison the std:: names we might use inside __gnu_cxx to ensure they're
-// properly qualified.
-struct allocator;
-struct pair;
-struct equal_to;
-struct unique_ptr;
+
#include <ext/hash_set>
+#include <cassert>
#include "test_macros.h"
+#include "count_new.hpp"
-namespace __gnu_cxx {
-template class hash_set<int>;
+void test_default_does_not_allocate() {
+ DisableAllocationGuard g;
+ ((void)g);
+ {
+ __gnu_cxx::hash_set<int> h;
+ assert(h.bucket_count() == 0);
+ }
+ {
+ __gnu_cxx::hash_multiset<int> h;
+ assert(h.bucket_count() == 0);
+ }
}
int main(int, char**) {
- typedef __gnu_cxx::hash_set<int> Set;
- Set s;
- Set s2(s);
- ((void)s2);
-
- return 0;
+ test_default_does_not_allocate();
}
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// Prevent emission of the deprecated warning.
+#ifdef __clang__
+#pragma clang diagnostic ignored "-W#warnings"
+#endif
+// Poison the std:: names we might use inside __gnu_cxx to ensure they're
+// properly qualified.
+struct allocator;
+struct pair;
+struct equal_to;
+struct unique_ptr;
+#include <ext/hash_set>
+
+#include "test_macros.h"
+
+namespace __gnu_cxx {
+template class hash_set<int>;
+}
+
+int main(int, char**) {
+ typedef __gnu_cxx::hash_set<int> Set;
+ Set s;
+ Set s2(s);
+ ((void)s2);
+
+ return 0;
+}