+2017-10-26 Ville Voutilainen <ville.voutilainen@gmail.com>
+
+ Deduction guides for associative containers, debug mode deduction
+ guide fixes.
+ * include/bits/stl_iterator.h (__iter_key_t)
+ (__iter_val_t, __iter_to_alloc_t): New.
+ * include/bits/stl_map.h: Add deduction guides.
+ * include/bits/stl_multimap.h: Likewise.
+ * include/bits/stl_multiset.h: Likewise.
+ * include/bits/stl_set.h: Likewise.
+ * include/bits/unordered_map.h: Likewise.
+ * include/bits/unordered_set.h: Likewise.
+ * include/debug/deque: Likewise.
+ * include/debug/forward_list: Likewise.
+ * include/debug/list: Likewise.
+ * include/debug/map.h: Likewise.
+ * include/debug/multimap.h: Likewise.
+ * include/debug/multiset.h: Likewise.
+ * include/debug/set.h: Likewise.
+ * include/debug/unordered_map: Likewise.
+ * include/debug/unordered_set: Likewise.
+ * include/debug/vector: Likewise.
+ * testsuite/23_containers/map/cons/deduction.cc: New.
+ * testsuite/23_containers/multimap/cons/deduction.cc: Likewise.
+ * testsuite/23_containers/multiset/cons/deduction.cc: Likewise.
+ * testsuite/23_containers/set/cons/deduction.cc: Likewise.
+ * testsuite/23_containers/unordered_map/cons/deduction.cc: Likewise.
+ * testsuite/23_containers/unordered_multimap/cons/deduction.cc:
+ Likewise.
+ * testsuite/23_containers/unordered_multiset/cons/deduction.cc:
+ Likewise.
+ * testsuite/23_containers/unordered_set/cons/deduction.cc: Likewise.
+
2017-10-25 Jonathan Wakely <jwakely@redhat.com>
* doc/xml/manual/status_cxx2017.xml: Update C++17 status, and
#define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) (_Iter)
#endif // C++11
+#if __cpp_deduction_guides >= 201606
+ // These helper traits are used for deduction guides
+ // of associative containers.
+ template<typename _InputIterator>
+ using __iter_key_t = remove_const_t<
+ typename iterator_traits<_InputIterator>::value_type::first_type>;
+
+ template<typename _InputIterator>
+ using __iter_val_t =
+ typename iterator_traits<_InputIterator>::value_type::second_type;
+
+ template<typename _T1, typename _T2>
+ struct pair;
+
+ template<typename _InputIterator>
+ using __iter_to_alloc_t =
+ pair<add_const_t<__iter_key_t<_InputIterator>>,
+ __iter_val_t<_InputIterator>>;
+
+#endif
+
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace
const map<_K1, _T1, _C1, _A1>&);
};
+
+#if __cpp_deduction_guides >= 201606
+
+ template<typename _InputIterator,
+ typename _Compare = less<__iter_key_t<_InputIterator>>,
+ typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ map(_InputIterator, _InputIterator,
+ _Compare = _Compare(), _Allocator = _Allocator())
+ -> map<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>,
+ _Compare, _Allocator>;
+
+ template<typename _Key, typename _Tp, typename _Compare = less<_Key>,
+ typename _Allocator = allocator<pair<const _Key, _Tp>>,
+ typename = _RequireAllocator<_Allocator>>
+ map(initializer_list<pair<_Key, _Tp>>,
+ _Compare = _Compare(), _Allocator = _Allocator())
+ -> map<_Key, _Tp, _Compare, _Allocator>;
+
+ template <typename _InputIterator, typename _Allocator,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ map(_InputIterator, _InputIterator, _Allocator)
+ -> map<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>,
+ less<__iter_key_t<_InputIterator>>, _Allocator>;
+
+ template<typename _Key, typename _Tp, typename _Allocator,
+ typename = _RequireAllocator<_Allocator>>
+ map(initializer_list<pair<_Key, _Tp>>, _Allocator)
+ -> map<_Key, _Tp, less<_Key>, _Allocator>;
+
+#endif
+
/**
* @brief Map equality comparison.
* @param __x A %map.
const multimap<_K1, _T1, _C1, _A1>&);
};
+#if __cpp_deduction_guides >= 201606
+
+ template<typename _InputIterator,
+ typename _Compare = less<__iter_key_t<_InputIterator>>,
+ typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ multimap(_InputIterator, _InputIterator,
+ _Compare = _Compare(), _Allocator = _Allocator())
+ -> multimap<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>,
+ _Compare, _Allocator>;
+
+ template<typename _Key, typename _Tp, typename _Compare = less<_Key>,
+ typename _Allocator = allocator<pair<const _Key, _Tp>>,
+ typename = _RequireAllocator<_Allocator>>
+ multimap(initializer_list<pair<_Key, _Tp>>,
+ _Compare = _Compare(), _Allocator = _Allocator())
+ -> multimap<_Key, _Tp, _Compare, _Allocator>;
+
+ template<typename _InputIterator, typename _Allocator,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ multimap(_InputIterator, _InputIterator, _Allocator)
+ -> multimap<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>,
+ less<__iter_key_t<_InputIterator>>, _Allocator>;
+
+ template<typename _Key, typename _Tp, typename _Allocator,
+ typename = _RequireAllocator<_Allocator>>
+ multimap(initializer_list<pair<_Key, _Tp>>, _Allocator)
+ -> multimap<_Key, _Tp, less<_Key>, _Allocator>;
+
+#endif
+
/**
* @brief Multimap equality comparison.
* @param __x A %multimap.
const multiset<_K1, _C1, _A1>&);
};
+#if __cpp_deduction_guides >= 201606
+
+ template<typename _InputIterator,
+ typename _Compare =
+ less<typename iterator_traits<_InputIterator>::value_type>,
+ typename _Allocator =
+ allocator<typename iterator_traits<_InputIterator>::value_type>,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ multiset(_InputIterator, _InputIterator,
+ _Compare = _Compare(), _Allocator = _Allocator())
+ -> multiset<typename iterator_traits<_InputIterator>::value_type,
+ _Compare, _Allocator>;
+
+ template<typename _Key,
+ typename _Compare = less<_Key>,
+ typename _Allocator = allocator<_Key>,
+ typename = _RequireAllocator<_Allocator>>
+ multiset(initializer_list<_Key>,
+ _Compare = _Compare(), _Allocator = _Allocator())
+ -> multiset<_Key, _Compare, _Allocator>;
+
+ template<typename _InputIterator, typename _Allocator,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ multiset(_InputIterator, _InputIterator, _Allocator)
+ -> multiset<typename iterator_traits<_InputIterator>::value_type,
+ less<typename iterator_traits<_InputIterator>::value_type>,
+ _Allocator>;
+
+ template<typename _Key, typename _Allocator,
+ typename = _RequireAllocator<_Allocator>>
+ multiset(initializer_list<_Key>, _Allocator)
+ -> multiset<_Key, less<_Key>, _Allocator>;
+
+#endif
+
/**
* @brief Multiset equality comparison.
* @param __x A %multiset.
_S_get_tree(_GLIBCXX_STD_C::multiset<_Val, _Cmp2, _Alloc>& __set)
{ return __set._M_t; }
};
+
#endif // C++17
_GLIBCXX_END_NAMESPACE_VERSION
operator<(const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&);
};
+#if __cpp_deduction_guides >= 201606
+
+ template<typename _InputIterator,
+ typename _Compare =
+ less<typename iterator_traits<_InputIterator>::value_type>,
+ typename _Allocator =
+ allocator<typename iterator_traits<_InputIterator>::value_type>,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ set(_InputIterator, _InputIterator,
+ _Compare = _Compare(), _Allocator = _Allocator())
+ -> set<typename iterator_traits<_InputIterator>::value_type,
+ _Compare, _Allocator>;
+
+ template<typename _Key, typename _Compare = less<_Key>,
+ typename _Allocator = allocator<_Key>,
+ typename = _RequireAllocator<_Allocator>>
+ set(initializer_list<_Key>,
+ _Compare = _Compare(), _Allocator = _Allocator())
+ -> set<_Key, _Compare, _Allocator>;
+
+ template<typename _InputIterator, typename _Allocator,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ set(_InputIterator, _InputIterator, _Allocator)
+ -> set<typename iterator_traits<_InputIterator>::value_type,
+ less<typename iterator_traits<_InputIterator>::value_type>,
+ _Allocator>;
+
+ template<typename _Key, typename _Allocator,
+ typename = _RequireAllocator<_Allocator>>
+ set(initializer_list<_Key>, _Allocator)
+ -> set<_Key, less<_Key>, _Allocator>;
+
+#endif
/**
* @brief Set equality comparison.
const unordered_map<_Key1, _Tp1, _Hash1, _Pred1, _Alloc1>&);
};
+#if __cpp_deduction_guides >= 201606
+
+ template<typename _InputIterator,
+ typename _Hash = hash<__iter_key_t<_InputIterator>>,
+ typename _Pred = equal_to<__iter_key_t<_InputIterator>>,
+ typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_map(_InputIterator, _InputIterator,
+ typename unordered_map<int, int>::size_type = {},
+ _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
+ -> unordered_map<__iter_key_t<_InputIterator>,
+ __iter_val_t<_InputIterator>,
+ _Hash, _Pred, _Allocator>;
+
+ template<typename _Key, typename _Tp, typename _Hash = hash<_Key>,
+ typename _Pred = equal_to<_Key>,
+ typename _Allocator = allocator<pair<const _Key, _Tp>>,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_map(initializer_list<pair<_Key, _Tp>>,
+ typename unordered_map<int, int>::size_type = {},
+ _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
+ -> unordered_map<_Key, _Tp, _Hash, _Pred, _Allocator>;
+
+ template<typename _InputIterator, typename _Allocator,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_map(_InputIterator, _InputIterator,
+ typename unordered_map<int, int>::size_type, _Allocator)
+ -> unordered_map<__iter_key_t<_InputIterator>,
+ __iter_val_t<_InputIterator>,
+ hash<__iter_key_t<_InputIterator>>,
+ equal_to<__iter_key_t<_InputIterator>>,
+ _Allocator>;
+
+ template<typename _InputIterator, typename _Allocator,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_map(_InputIterator, _InputIterator, _Allocator)
+ -> unordered_map<__iter_key_t<_InputIterator>,
+ __iter_val_t<_InputIterator>,
+ hash<__iter_key_t<_InputIterator>>,
+ equal_to<__iter_key_t<_InputIterator>>,
+ _Allocator>;
+
+ template<typename _InputIterator, typename _Hash, typename _Allocator,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_map(_InputIterator, _InputIterator,
+ typename unordered_map<int, int>::size_type,
+ _Hash, _Allocator)
+ -> unordered_map<__iter_key_t<_InputIterator>,
+ __iter_val_t<_InputIterator>, _Hash,
+ equal_to<__iter_key_t<_InputIterator>>, _Allocator>;
+
+ template<typename _Key, typename _Tp, typename _Allocator,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_map(initializer_list<pair<_Key, _Tp>>,
+ typename unordered_map<int, int>::size_type,
+ _Allocator)
+ -> unordered_map<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>;
+
+ template<typename _Key, typename _Tp, typename _Allocator,
+ _RequireAllocator<_Allocator>>
+ unordered_map(initializer_list<pair<_Key, _Tp>>, _Allocator)
+ -> unordered_map<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>;
+
+ template<typename _Key, typename _Tp, typename _Hash, typename _Allocator,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_map(initializer_list<pair<_Key, _Tp>>,
+ typename unordered_map<int, int>::size_type,
+ _Hash, _Allocator)
+ -> unordered_map<_Key, _Tp, _Hash, equal_to<_Key>, _Allocator>;
+
+#endif
+
/**
* @brief A standard container composed of equivalent keys
* (possibly containing multiple of each key value) that associates
_Hash1, _Pred1, _Alloc1>&);
};
+#if __cpp_deduction_guides >= 201606
+
+ template<typename _InputIterator,
+ typename _Hash = hash<__iter_key_t<_InputIterator>>,
+ typename _Pred = equal_to<__iter_key_t<_InputIterator>>,
+ typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_multimap(_InputIterator, _InputIterator,
+ unordered_multimap<int, int>::size_type = {},
+ _Hash = _Hash(), _Pred = _Pred(),
+ _Allocator = _Allocator())
+ -> unordered_multimap<__iter_key_t<_InputIterator>,
+ __iter_val_t<_InputIterator>, _Hash, _Pred,
+ _Allocator>;
+
+ template<typename _Key, typename _Tp, typename _Hash = hash<_Key>,
+ typename _Pred = equal_to<_Key>,
+ typename _Allocator = allocator<pair<const _Key, _Tp>>,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_multimap(initializer_list<pair<_Key, _Tp>>,
+ unordered_multimap<int, int>::size_type = {},
+ _Hash = _Hash(), _Pred = _Pred(),
+ _Allocator = _Allocator())
+ -> unordered_multimap<_Key, _Tp, _Hash, _Pred, _Allocator>;
+
+ template<typename _InputIterator, typename _Allocator,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_multimap(_InputIterator, _InputIterator,
+ unordered_multimap<int, int>::size_type, _Allocator)
+ -> unordered_multimap<__iter_key_t<_InputIterator>,
+ __iter_val_t<_InputIterator>,
+ hash<__iter_key_t<_InputIterator>>,
+ equal_to<__iter_key_t<_InputIterator>>, _Allocator>;
+
+ template<typename _InputIterator, typename _Allocator,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_multimap(_InputIterator, _InputIterator, _Allocator)
+ -> unordered_multimap<__iter_key_t<_InputIterator>,
+ __iter_val_t<_InputIterator>,
+ hash<__iter_key_t<_InputIterator>>,
+ equal_to<__iter_key_t<_InputIterator>>, _Allocator>;
+
+ template<typename _InputIterator, typename _Hash, typename _Allocator,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_multimap(_InputIterator, _InputIterator,
+ unordered_multimap<int, int>::size_type, _Hash,
+ _Allocator)
+ -> unordered_multimap<__iter_key_t<_InputIterator>,
+ __iter_val_t<_InputIterator>, _Hash,
+ equal_to<__iter_key_t<_InputIterator>>, _Allocator>;
+
+ template<typename _Key, typename _Tp, typename _Allocator,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_multimap(initializer_list<pair<_Key, _Tp>>,
+ unordered_multimap<int, int>::size_type,
+ _Allocator)
+ -> unordered_multimap<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>;
+
+ template<typename _Key, typename _Tp, typename _Allocator,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_multimap(initializer_list<pair<_Key, _Tp>>, _Allocator)
+ -> unordered_multimap<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>;
+
+ template<typename _Key, typename _Tp, typename _Hash, typename _Allocator,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_multimap(initializer_list<pair<_Key, _Tp>>,
+ unordered_multimap<int, int>::size_type,
+ _Hash, _Allocator)
+ -> unordered_multimap<_Key, _Tp, _Hash, equal_to<_Key>, _Allocator>;
+
+#endif
+
template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
inline void
swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
const unordered_set<_Value1, _Hash1, _Pred1, _Alloc1>&);
};
+#if __cpp_deduction_guides >= 201606
+
+ template<typename _InputIterator,
+ typename _Hash =
+ hash<typename iterator_traits<_InputIterator>::value_type>,
+ typename _Pred =
+ equal_to<typename iterator_traits<_InputIterator>::value_type>,
+ typename _Allocator =
+ allocator<typename iterator_traits<_InputIterator>::value_type>,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_set(_InputIterator, _InputIterator,
+ unordered_set<int>::size_type = {},
+ _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
+ -> unordered_set<typename iterator_traits<_InputIterator>::value_type,
+ _Hash, _Pred, _Allocator>;
+
+ template<typename _Tp, typename _Hash = hash<_Tp>,
+ typename _Pred = equal_to<_Tp>,
+ typename _Allocator = allocator<_Tp>,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_set(initializer_list<_Tp>,
+ unordered_set<int>::size_type = {},
+ _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
+ -> unordered_set<_Tp, _Hash, _Pred, _Allocator>;
+
+ template<typename _InputIterator, typename _Allocator,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_set(_InputIterator, _InputIterator,
+ unordered_set<int>::size_type, _Allocator)
+ -> unordered_set<typename iterator_traits<_InputIterator>::value_type,
+ hash<
+ typename iterator_traits<_InputIterator>::value_type>,
+ equal_to<
+ typename iterator_traits<_InputIterator>::value_type>,
+ _Allocator>;
+
+ template<typename _InputIterator, typename _Hash, typename _Allocator,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_set(_InputIterator, _InputIterator,
+ unordered_set<int>::size_type,
+ _Hash, _Allocator)
+ -> unordered_set<typename iterator_traits<_InputIterator>::value_type,
+ _Hash,
+ equal_to<
+ typename iterator_traits<_InputIterator>::value_type>,
+ _Allocator>;
+
+ template<typename _Tp, typename _Allocator,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_set(initializer_list<_Tp>,
+ unordered_set<int>::size_type, _Allocator)
+ -> unordered_set<_Tp, hash<_Tp>, equal_to<_Tp>, _Allocator>;
+
+ template<typename _Tp, typename _Hash, typename _Allocator,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_set(initializer_list<_Tp>,
+ unordered_set<int>::size_type, _Hash, _Allocator)
+ -> unordered_set<_Tp, _Hash, equal_to<_Tp>, _Allocator>;
+
+#endif
+
/**
* @brief A standard container composed of equivalent keys
* (possibly containing multiple of each key value) in which the
const unordered_multiset<_Value1, _Hash1, _Pred1, _Alloc1>&);
};
+
+#if __cpp_deduction_guides >= 201606
+
+ template<typename _InputIterator,
+ typename _Hash =
+ hash<typename iterator_traits<_InputIterator>::value_type>,
+ typename _Pred =
+ equal_to<typename iterator_traits<_InputIterator>::value_type>,
+ typename _Allocator =
+ allocator<typename iterator_traits<_InputIterator>::value_type>,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_multiset(_InputIterator, _InputIterator,
+ unordered_multiset<int>::size_type = {},
+ _Hash = _Hash(), _Pred = _Pred(),
+ _Allocator = _Allocator())
+ -> unordered_multiset<typename iterator_traits<_InputIterator>::value_type,
+ _Hash, _Pred, _Allocator>;
+
+ template<typename _Tp, typename _Hash = hash<_Tp>,
+ typename _Pred = equal_to<_Tp>,
+ typename _Allocator = allocator<_Tp>,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_multiset(initializer_list<_Tp>,
+ unordered_multiset<int>::size_type = {},
+ _Hash = _Hash(), _Pred = _Pred(),
+ _Allocator = _Allocator())
+ -> unordered_multiset<_Tp, _Hash, _Pred, _Allocator>;
+
+ template<typename _InputIterator, typename _Allocator,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_multiset(_InputIterator, _InputIterator,
+ unordered_multiset<int>::size_type, _Allocator)
+ -> unordered_multiset<typename iterator_traits<_InputIterator>::value_type,
+ hash<typename
+ iterator_traits<_InputIterator>::value_type>,
+ equal_to<typename
+ iterator_traits<_InputIterator>::value_type>,
+ _Allocator>;
+
+ template<typename _InputIterator, typename _Hash, typename _Allocator,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_multiset(_InputIterator, _InputIterator,
+ unordered_multiset<int>::size_type,
+ _Hash, _Allocator)
+ -> unordered_multiset<typename
+ iterator_traits<_InputIterator>::value_type,
+ _Hash,
+ equal_to<
+ typename
+ iterator_traits<_InputIterator>::value_type>,
+ _Allocator>;
+
+ template<typename _Tp, typename _Allocator,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_multiset(initializer_list<_Tp>,
+ unordered_multiset<int>::size_type, _Allocator)
+ -> unordered_multiset<_Tp, hash<_Tp>, equal_to<_Tp>, _Allocator>;
+
+ template<typename _Tp, typename _Hash, typename _Allocator,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_multiset(initializer_list<_Tp>,
+ unordered_multiset<int>::size_type, _Hash, _Allocator)
+ -> unordered_multiset<_Tp, _Hash, equal_to<_Tp>, _Allocator>;
+
+#endif
+
template<class _Value, class _Hash, class _Pred, class _Alloc>
inline void
swap(unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
_M_base() const _GLIBCXX_NOEXCEPT { return *this; }
};
+#if __cpp_deduction_guides >= 201606
+ template<typename _InputIterator, typename _ValT
+ = typename iterator_traits<_InputIterator>::value_type,
+ typename _Allocator = allocator<_ValT>,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ deque(_InputIterator, _InputIterator, _Allocator = _Allocator())
+ -> deque<_ValT, _Allocator>;
+#endif
+
template<typename _Tp, typename _Alloc>
inline bool
operator==(const deque<_Tp, _Alloc>& __lhs,
_M_base() const noexcept { return *this; }
};
+#if __cpp_deduction_guides >= 201606
+ template<typename _InputIterator, typename _ValT
+ = typename iterator_traits<_InputIterator>::value_type,
+ typename _Allocator = allocator<_ValT>,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ forward_list(_InputIterator, _InputIterator, _Allocator = _Allocator())
+ -> forward_list<_ValT, _Allocator>;
+#endif
+
template<typename _Tp, typename _Alloc>
bool
operator==(const forward_list<_Tp, _Alloc>& __lx,
_M_base() const _GLIBCXX_NOEXCEPT { return *this; }
};
+#if __cpp_deduction_guides >= 201606
+ template<typename _InputIterator, typename _ValT
+ = typename iterator_traits<_InputIterator>::value_type,
+ typename _Allocator = allocator<_ValT>,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ list(_InputIterator, _InputIterator, _Allocator = _Allocator())
+ -> list<_ValT, _Allocator>;
+#endif
+
template<typename _Tp, typename _Alloc>
inline bool
operator==(const list<_Tp, _Alloc>& __lhs,
_M_base() const _GLIBCXX_NOEXCEPT { return *this; }
};
+#if __cpp_deduction_guides >= 201606
+
+ template<typename _InputIterator,
+ typename _Compare = less<__iter_key_t<_InputIterator>>,
+ typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ map(_InputIterator, _InputIterator,
+ _Compare = _Compare(), _Allocator = _Allocator())
+ -> map<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>,
+ _Compare, _Allocator>;
+
+ template<typename _Key, typename _Tp, typename _Compare = less<_Key>,
+ typename _Allocator = allocator<pair<const _Key, _Tp>>,
+ typename = _RequireAllocator<_Allocator>>
+ map(initializer_list<pair<_Key, _Tp>>,
+ _Compare = _Compare(), _Allocator = _Allocator())
+ -> map<_Key, _Tp, _Compare, _Allocator>;
+
+ template <typename _InputIterator, typename _Allocator,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ map(_InputIterator, _InputIterator, _Allocator)
+ -> map<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>,
+ less<__iter_key_t<_InputIterator>>, _Allocator>;
+
+ template<typename _Key, typename _Tp, typename _Allocator,
+ typename = _RequireAllocator<_Allocator>>
+ map(initializer_list<pair<_Key, _Tp>>, _Allocator)
+ -> map<_Key, _Tp, less<_Key>, _Allocator>;
+
+#endif
+
template<typename _Key, typename _Tp,
typename _Compare, typename _Allocator>
inline bool
_M_base() const _GLIBCXX_NOEXCEPT { return *this; }
};
+#if __cpp_deduction_guides >= 201606
+
+ template<typename _InputIterator,
+ typename _Compare = less<__iter_key_t<_InputIterator>>,
+ typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ multimap(_InputIterator, _InputIterator,
+ _Compare = _Compare(), _Allocator = _Allocator())
+ -> multimap<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>,
+ _Compare, _Allocator>;
+
+ template<typename _Key, typename _Tp, typename _Compare = less<_Key>,
+ typename _Allocator = allocator<pair<const _Key, _Tp>>,
+ typename = _RequireAllocator<_Allocator>>
+ multimap(initializer_list<pair<_Key, _Tp>>,
+ _Compare = _Compare(), _Allocator = _Allocator())
+ -> multimap<_Key, _Tp, _Compare, _Allocator>;
+
+ template<typename _InputIterator, typename _Allocator,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ multimap(_InputIterator, _InputIterator, _Allocator)
+ -> multimap<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>,
+ less<__iter_key_t<_InputIterator>>, _Allocator>;
+
+ template<typename _Key, typename _Tp, typename _Allocator,
+ typename = _RequireAllocator<_Allocator>>
+ multimap(initializer_list<pair<_Key, _Tp>>, _Allocator)
+ -> multimap<_Key, _Tp, less<_Key>, _Allocator>;
+
+#endif
+
template<typename _Key, typename _Tp,
typename _Compare, typename _Allocator>
inline bool
_M_base() const _GLIBCXX_NOEXCEPT { return *this; }
};
+#if __cpp_deduction_guides >= 201606
+
+ template<typename _InputIterator,
+ typename _Compare =
+ less<typename iterator_traits<_InputIterator>::value_type>,
+ typename _Allocator =
+ allocator<typename iterator_traits<_InputIterator>::value_type>,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ multiset(_InputIterator, _InputIterator,
+ _Compare = _Compare(), _Allocator = _Allocator())
+ -> multiset<typename iterator_traits<_InputIterator>::value_type,
+ _Compare, _Allocator>;
+
+ template<typename _Key,
+ typename _Compare = less<_Key>,
+ typename _Allocator = allocator<_Key>,
+ typename = _RequireAllocator<_Allocator>>
+ multiset(initializer_list<_Key>,
+ _Compare = _Compare(), _Allocator = _Allocator())
+ -> multiset<_Key, _Compare, _Allocator>;
+
+ template<typename _InputIterator, typename _Allocator,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ multiset(_InputIterator, _InputIterator, _Allocator)
+ -> multiset<typename iterator_traits<_InputIterator>::value_type,
+ less<typename iterator_traits<_InputIterator>::value_type>,
+ _Allocator>;
+
+ template<typename _Key, typename _Allocator,
+ typename = _RequireAllocator<_Allocator>>
+ multiset(initializer_list<_Key>, _Allocator)
+ -> multiset<_Key, less<_Key>, _Allocator>;
+
+#endif
+
template<typename _Key, typename _Compare, typename _Allocator>
inline bool
operator==(const multiset<_Key, _Compare, _Allocator>& __lhs,
_M_base() const _GLIBCXX_NOEXCEPT { return *this; }
};
+#if __cpp_deduction_guides >= 201606
+
+ template<typename _InputIterator,
+ typename _Compare =
+ less<typename iterator_traits<_InputIterator>::value_type>,
+ typename _Allocator =
+ allocator<typename iterator_traits<_InputIterator>::value_type>,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ set(_InputIterator, _InputIterator,
+ _Compare = _Compare(), _Allocator = _Allocator())
+ -> set<typename iterator_traits<_InputIterator>::value_type,
+ _Compare, _Allocator>;
+
+ template<typename _Key, typename _Compare = less<_Key>,
+ typename _Allocator = allocator<_Key>,
+ typename = _RequireAllocator<_Allocator>>
+ set(initializer_list<_Key>,
+ _Compare = _Compare(), _Allocator = _Allocator())
+ -> set<_Key, _Compare, _Allocator>;
+
+ template<typename _InputIterator, typename _Allocator,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ set(_InputIterator, _InputIterator, _Allocator)
+ -> set<typename iterator_traits<_InputIterator>::value_type,
+ less<typename iterator_traits<_InputIterator>::value_type>,
+ _Allocator>;
+
+ template<typename _Key, typename _Allocator,
+ typename = _RequireAllocator<_Allocator>>
+ set(initializer_list<_Key>, _Allocator)
+ -> set<_Key, less<_Key>, _Allocator>;
+
+#endif
+
template<typename _Key, typename _Compare, typename _Allocator>
inline bool
operator==(const set<_Key, _Compare, _Allocator>& __lhs,
}
};
+#if __cpp_deduction_guides >= 201606
+
+ template<typename _InputIterator,
+ typename _Hash = hash<__iter_key_t<_InputIterator>>,
+ typename _Pred = equal_to<__iter_key_t<_InputIterator>>,
+ typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_map(_InputIterator, _InputIterator,
+ typename unordered_map<int, int>::size_type = {},
+ _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
+ -> unordered_map<__iter_key_t<_InputIterator>,
+ __iter_val_t<_InputIterator>,
+ _Hash, _Pred, _Allocator>;
+
+ template<typename _Key, typename _Tp, typename _Hash = hash<_Key>,
+ typename _Pred = equal_to<_Key>,
+ typename _Allocator = allocator<pair<const _Key, _Tp>>,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_map(initializer_list<pair<_Key, _Tp>>,
+ typename unordered_map<int, int>::size_type = {},
+ _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
+ -> unordered_map<_Key, _Tp, _Hash, _Pred, _Allocator>;
+
+ template<typename _InputIterator, typename _Allocator,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_map(_InputIterator, _InputIterator,
+ typename unordered_map<int, int>::size_type, _Allocator)
+ -> unordered_map<__iter_key_t<_InputIterator>,
+ __iter_val_t<_InputIterator>,
+ hash<__iter_key_t<_InputIterator>>,
+ equal_to<__iter_key_t<_InputIterator>>,
+ _Allocator>;
+
+ template<typename _InputIterator, typename _Allocator,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_map(_InputIterator, _InputIterator, _Allocator)
+ -> unordered_map<__iter_key_t<_InputIterator>,
+ __iter_val_t<_InputIterator>,
+ hash<__iter_key_t<_InputIterator>>,
+ equal_to<__iter_key_t<_InputIterator>>,
+ _Allocator>;
+
+ template<typename _InputIterator, typename _Hash, typename _Allocator,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_map(_InputIterator, _InputIterator,
+ typename unordered_map<int, int>::size_type,
+ _Hash, _Allocator)
+ -> unordered_map<__iter_key_t<_InputIterator>,
+ __iter_val_t<_InputIterator>, _Hash,
+ equal_to<__iter_key_t<_InputIterator>>, _Allocator>;
+
+ template<typename _Key, typename _Tp, typename _Allocator,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_map(initializer_list<pair<_Key, _Tp>>,
+ typename unordered_map<int, int>::size_type,
+ _Allocator)
+ -> unordered_map<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>;
+
+ template<typename _Key, typename _Tp, typename _Allocator,
+ _RequireAllocator<_Allocator>>
+ unordered_map(initializer_list<pair<_Key, _Tp>>, _Allocator)
+ -> unordered_map<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>;
+
+ template<typename _Key, typename _Tp, typename _Hash, typename _Allocator,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_map(initializer_list<pair<_Key, _Tp>>,
+ typename unordered_map<int, int>::size_type,
+ _Hash, _Allocator)
+ -> unordered_map<_Key, _Tp, _Hash, equal_to<_Key>, _Allocator>;
+
+#endif
+
template<typename _Key, typename _Tp, typename _Hash,
typename _Pred, typename _Alloc>
inline void
}
};
+#if __cpp_deduction_guides >= 201606
+
+ template<typename _InputIterator,
+ typename _Hash = hash<__iter_key_t<_InputIterator>>,
+ typename _Pred = equal_to<__iter_key_t<_InputIterator>>,
+ typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_multimap(_InputIterator, _InputIterator,
+ unordered_multimap<int, int>::size_type = {},
+ _Hash = _Hash(), _Pred = _Pred(),
+ _Allocator = _Allocator())
+ -> unordered_multimap<__iter_key_t<_InputIterator>,
+ __iter_val_t<_InputIterator>, _Hash, _Pred,
+ _Allocator>;
+
+ template<typename _Key, typename _Tp, typename _Hash = hash<_Key>,
+ typename _Pred = equal_to<_Key>,
+ typename _Allocator = allocator<pair<const _Key, _Tp>>,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_multimap(initializer_list<pair<_Key, _Tp>>,
+ unordered_multimap<int, int>::size_type = {},
+ _Hash = _Hash(), _Pred = _Pred(),
+ _Allocator = _Allocator())
+ -> unordered_multimap<_Key, _Tp, _Hash, _Pred, _Allocator>;
+
+ template<typename _InputIterator, typename _Allocator,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_multimap(_InputIterator, _InputIterator,
+ unordered_multimap<int, int>::size_type, _Allocator)
+ -> unordered_multimap<__iter_key_t<_InputIterator>,
+ __iter_val_t<_InputIterator>,
+ hash<__iter_key_t<_InputIterator>>,
+ equal_to<__iter_key_t<_InputIterator>>, _Allocator>;
+
+ template<typename _InputIterator, typename _Allocator,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_multimap(_InputIterator, _InputIterator, _Allocator)
+ -> unordered_multimap<__iter_key_t<_InputIterator>,
+ __iter_val_t<_InputIterator>,
+ hash<__iter_key_t<_InputIterator>>,
+ equal_to<__iter_key_t<_InputIterator>>, _Allocator>;
+
+ template<typename _InputIterator, typename _Hash, typename _Allocator,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_multimap(_InputIterator, _InputIterator,
+ unordered_multimap<int, int>::size_type, _Hash,
+ _Allocator)
+ -> unordered_multimap<__iter_key_t<_InputIterator>,
+ __iter_val_t<_InputIterator>, _Hash,
+ equal_to<__iter_key_t<_InputIterator>>, _Allocator>;
+
+ template<typename _Key, typename _Tp, typename _Allocator,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_multimap(initializer_list<pair<_Key, _Tp>>,
+ unordered_multimap<int, int>::size_type,
+ _Allocator)
+ -> unordered_multimap<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>;
+
+ template<typename _Key, typename _Tp, typename _Allocator,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_multimap(initializer_list<pair<_Key, _Tp>>, _Allocator)
+ -> unordered_multimap<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>;
+
+ template<typename _Key, typename _Tp, typename _Hash, typename _Allocator,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_multimap(initializer_list<pair<_Key, _Tp>>,
+ unordered_multimap<int, int>::size_type,
+ _Hash, _Allocator)
+ -> unordered_multimap<_Key, _Tp, _Hash, equal_to<_Key>, _Allocator>;
+
+#endif
+
template<typename _Key, typename _Tp, typename _Hash,
typename _Pred, typename _Alloc>
inline void
}
};
+#if __cpp_deduction_guides >= 201606
+
+ template<typename _InputIterator,
+ typename _Hash =
+ hash<typename iterator_traits<_InputIterator>::value_type>,
+ typename _Pred =
+ equal_to<typename iterator_traits<_InputIterator>::value_type>,
+ typename _Allocator =
+ allocator<typename iterator_traits<_InputIterator>::value_type>,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_set(_InputIterator, _InputIterator,
+ unordered_set<int>::size_type = {},
+ _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
+ -> unordered_set<typename iterator_traits<_InputIterator>::value_type,
+ _Hash, _Pred, _Allocator>;
+
+ template<typename _Tp, typename _Hash = hash<_Tp>,
+ typename _Pred = equal_to<_Tp>,
+ typename _Allocator = allocator<_Tp>,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_set(initializer_list<_Tp>,
+ unordered_set<int>::size_type = {},
+ _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
+ -> unordered_set<_Tp, _Hash, _Pred, _Allocator>;
+
+ template<typename _InputIterator, typename _Allocator,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_set(_InputIterator, _InputIterator,
+ unordered_set<int>::size_type, _Allocator)
+ -> unordered_set<typename iterator_traits<_InputIterator>::value_type,
+ hash<
+ typename iterator_traits<_InputIterator>::value_type>,
+ equal_to<
+ typename iterator_traits<_InputIterator>::value_type>,
+ _Allocator>;
+
+ template<typename _InputIterator, typename _Hash, typename _Allocator,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_set(_InputIterator, _InputIterator,
+ unordered_set<int>::size_type,
+ _Hash, _Allocator)
+ -> unordered_set<typename iterator_traits<_InputIterator>::value_type,
+ _Hash,
+ equal_to<
+ typename iterator_traits<_InputIterator>::value_type>,
+ _Allocator>;
+
+ template<typename _Tp, typename _Allocator,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_set(initializer_list<_Tp>,
+ unordered_set<int>::size_type, _Allocator)
+ -> unordered_set<_Tp, hash<_Tp>, equal_to<_Tp>, _Allocator>;
+
+ template<typename _Tp, typename _Hash, typename _Allocator,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_set(initializer_list<_Tp>,
+ unordered_set<int>::size_type, _Hash, _Allocator)
+ -> unordered_set<_Tp, _Hash, equal_to<_Tp>, _Allocator>;
+
+#endif
+
template<typename _Value, typename _Hash, typename _Pred, typename _Alloc>
inline void
swap(unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
}
};
+#if __cpp_deduction_guides >= 201606
+
+ template<typename _InputIterator,
+ typename _Hash =
+ hash<typename iterator_traits<_InputIterator>::value_type>,
+ typename _Pred =
+ equal_to<typename iterator_traits<_InputIterator>::value_type>,
+ typename _Allocator =
+ allocator<typename iterator_traits<_InputIterator>::value_type>,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_multiset(_InputIterator, _InputIterator,
+ unordered_multiset<int>::size_type = {},
+ _Hash = _Hash(), _Pred = _Pred(),
+ _Allocator = _Allocator())
+ -> unordered_multiset<typename iterator_traits<_InputIterator>::value_type,
+ _Hash, _Pred, _Allocator>;
+
+ template<typename _Tp, typename _Hash = hash<_Tp>,
+ typename _Pred = equal_to<_Tp>,
+ typename _Allocator = allocator<_Tp>,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_multiset(initializer_list<_Tp>,
+ unordered_multiset<int>::size_type = {},
+ _Hash = _Hash(), _Pred = _Pred(),
+ _Allocator = _Allocator())
+ -> unordered_multiset<_Tp, _Hash, _Pred, _Allocator>;
+
+ template<typename _InputIterator, typename _Allocator,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_multiset(_InputIterator, _InputIterator,
+ unordered_multiset<int>::size_type, _Allocator)
+ -> unordered_multiset<typename iterator_traits<_InputIterator>::value_type,
+ hash<typename
+ iterator_traits<_InputIterator>::value_type>,
+ equal_to<typename
+ iterator_traits<_InputIterator>::value_type>,
+ _Allocator>;
+
+ template<typename _InputIterator, typename _Hash, typename _Allocator,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_multiset(_InputIterator, _InputIterator,
+ unordered_multiset<int>::size_type,
+ _Hash, _Allocator)
+ -> unordered_multiset<typename
+ iterator_traits<_InputIterator>::value_type,
+ _Hash,
+ equal_to<
+ typename
+ iterator_traits<_InputIterator>::value_type>,
+ _Allocator>;
+
+ template<typename _Tp, typename _Allocator,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_multiset(initializer_list<_Tp>,
+ unordered_multiset<int>::size_type, _Allocator)
+ -> unordered_multiset<_Tp, hash<_Tp>, equal_to<_Tp>, _Allocator>;
+
+ template<typename _Tp, typename _Hash, typename _Allocator,
+ typename = _RequireAllocator<_Allocator>>
+ unordered_multiset(initializer_list<_Tp>,
+ unordered_multiset<int>::size_type, _Hash, _Allocator)
+ -> unordered_multiset<_Tp, _Hash, equal_to<_Tp>, _Allocator>;
+
+#endif
+
template<typename _Value, typename _Hash, typename _Pred, typename _Alloc>
inline void
swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
_GLIBCXX_NOEXCEPT_IF(noexcept(__lhs.swap(__rhs)))
{ __lhs.swap(__rhs); }
+#if __cpp_deduction_guides >= 201606
+ template<typename _InputIterator, typename _ValT
+ = typename iterator_traits<_InputIterator>::value_type,
+ typename _Allocator = allocator<_ValT>,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ vector(_InputIterator, _InputIterator, _Allocator = _Allocator())
+ -> vector<_ValT, _Allocator>;
+#endif
+
} // namespace __debug
#if __cplusplus >= 201103L
--- /dev/null
+// { dg-options "-std=gnu++17" }
+// { dg-do compile { target c++17 } }
+
+#include <map>
+#include <testsuite_allocator.h>
+
+using __gnu_test::SimpleAllocator;
+
+static_assert(std::is_same_v<
+ decltype(std::map{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}}),
+ std::map<int, double>>);
+
+static_assert(std::is_same_v<
+ decltype(std::map{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}}}),
+ std::map<int, double>>);
+
+static_assert(std::is_same_v<
+ decltype(std::map{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
+ std::less<int>{}, {}}),
+ std::map<int, double>>);
+
+static_assert(std::is_same_v<
+ decltype(std::map{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
+ {}}),
+ std::map<int, double>>);
+
+static_assert(std::is_same_v<
+ decltype(std::map{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
+ {}, SimpleAllocator<std::pair<const int, double>>{}}),
+ std::map<int, double, std::less<int>,
+ SimpleAllocator<std::pair<const int, double>>>>);
+
+void f()
+{
+ std::map<int, double> x;
+ static_assert(std::is_same_v<
+ decltype(std::map(x.begin(), x.end())),
+ std::map<int, double>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::map{x.begin(), x.end(),
+ std::less<int>{},
+ std::allocator<std::pair<const int, double>>{}}),
+ std::map<int, double>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::map{x.begin(), x.end(),
+ std::less<int>{}, {}}),
+ std::map<int, double>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::map(x.begin(), x.end(),
+ {})),
+ std::map<int, double>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::map{x.begin(), x.end(),
+ {},
+ std::allocator<std::pair<const int, double>>{}}),
+ std::map<int, double>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::map{x.begin(), x.end(),
+ {},
+ SimpleAllocator<std::pair<const int, double>>{}}),
+ std::map<int, double, std::less<int>,
+ SimpleAllocator<std::pair<const int, double>>>>);
+}
--- /dev/null
+// { dg-options "-std=gnu++17" }
+// { dg-do compile { target c++17 } }
+
+#include <map>
+#include <testsuite_allocator.h>
+
+using __gnu_test::SimpleAllocator;
+
+static_assert(std::is_same_v<
+ decltype(std::multimap{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}}),
+ std::multimap<int, double>>);
+
+static_assert(std::is_same_v<
+ decltype(std::multimap{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}}}),
+ std::multimap<int, double>>);
+
+static_assert(std::is_same_v<
+ decltype(std::multimap{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
+ std::less<int>{}, {}}),
+ std::multimap<int, double>>);
+
+static_assert(std::is_same_v<
+ decltype(std::multimap{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
+ {}}),
+ std::multimap<int, double>>);
+
+static_assert(std::is_same_v<
+ decltype(std::multimap{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
+ {}, SimpleAllocator<std::pair<const int, double>>{}}),
+ std::multimap<int, double, std::less<int>,
+ SimpleAllocator<std::pair<const int, double>>>>);
+
+void f()
+{
+ std::multimap<int, double> x;
+ static_assert(std::is_same_v<
+ decltype(std::multimap(x.begin(), x.end())),
+ std::multimap<int, double>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::multimap{x.begin(), x.end(),
+ std::less<int>{},
+ std::allocator<std::pair<const int, double>>{}}),
+ std::multimap<int, double>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::multimap{x.begin(), x.end(),
+ std::less<int>{}, {}}),
+ std::multimap<int, double>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::multimap(x.begin(), x.end(),
+ {})),
+ std::multimap<int, double>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::multimap{x.begin(), x.end(),
+ {},
+ std::allocator<std::pair<const int, double>>{}}),
+ std::multimap<int, double>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::multimap{x.begin(), x.end(),
+ {},
+ SimpleAllocator<std::pair<const int, double>>{}}),
+ std::multimap<int, double, std::less<int>,
+ SimpleAllocator<std::pair<const int, double>>>>);
+}
--- /dev/null
+// { dg-options "-std=gnu++17" }
+// { dg-do compile { target c++17 } }
+
+#include <set>
+#include <testsuite_allocator.h>
+
+using __gnu_test::SimpleAllocator;
+
+static_assert(std::is_same_v<
+ decltype(std::multiset{1, 2, 3}),
+ std::multiset<int>>);
+
+static_assert(std::is_same_v<
+ decltype(std::multiset{1, 2, 3}),
+ std::multiset<int>>);
+
+static_assert(std::is_same_v<
+ decltype(std::multiset{{1, 2, 3},
+ std::less<int>{}, {}}),
+ std::multiset<int>>);
+
+static_assert(std::is_same_v<
+ decltype(std::multiset{{1, 2, 3},
+ {}}),
+ std::multiset<int>>);
+
+static_assert(std::is_same_v<
+ decltype(std::multiset{{1, 2, 3},
+ {}, SimpleAllocator<int>{}}),
+ std::multiset<int, std::less<int>,
+ SimpleAllocator<int>>>);
+
+void f()
+{
+ std::multiset<int> x;
+
+ static_assert(std::is_same_v<
+ decltype(std::multiset(x.begin(), x.end())),
+ std::multiset<int>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::multiset{x.begin(), x.end(),
+ std::less<int>{},
+ std::allocator<int>{}}),
+ std::multiset<int>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::multiset{x.begin(), x.end(),
+ std::less<int>{}, {}}),
+ std::multiset<int>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::multiset(x.begin(), x.end(),
+ {})),
+ std::multiset<int>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::multiset{x.begin(), x.end(),
+ {},
+ std::allocator<int>{}}),
+ std::multiset<int>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::multiset{x.begin(), x.end(),
+ {},
+ SimpleAllocator<int>{}}),
+ std::multiset<int, std::less<int>, SimpleAllocator<int>>>);
+}
--- /dev/null
+// { dg-options "-std=gnu++17" }
+// { dg-do compile { target c++17 } }
+
+#include <set>
+#include <testsuite_allocator.h>
+
+using __gnu_test::SimpleAllocator;
+
+static_assert(std::is_same_v<
+ decltype(std::set{1, 2, 3}),
+ std::set<int>>);
+
+static_assert(std::is_same_v<
+ decltype(std::set{1, 2, 3}),
+ std::set<int>>);
+
+static_assert(std::is_same_v<
+ decltype(std::set{{1, 2, 3},
+ std::less<int>{}, {}}),
+ std::set<int>>);
+
+static_assert(std::is_same_v<
+ decltype(std::set{{1, 2, 3},
+ {}}),
+ std::set<int>>);
+
+static_assert(std::is_same_v<
+ decltype(std::set{{1, 2, 3},
+ {}, SimpleAllocator<int>{}}),
+ std::set<int, std::less<int>,
+ SimpleAllocator<int>>>);
+
+void f()
+{
+ std::set<int> x;
+
+ static_assert(std::is_same_v<
+ decltype(std::set(x.begin(), x.end())),
+ std::set<int>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::set{x.begin(), x.end(),
+ std::less<int>{},
+ std::allocator<int>{}}),
+ std::set<int>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::set{x.begin(), x.end(),
+ std::less<int>{}, {}}),
+ std::set<int>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::set(x.begin(), x.end(),
+ {})),
+ std::set<int>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::set{x.begin(), x.end(),
+ {},
+ std::allocator<int>{}}),
+ std::set<int>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::set{x.begin(), x.end(),
+ {},
+ SimpleAllocator<int>{}}),
+ std::set<int, std::less<int>, SimpleAllocator<int>>>);
+}
--- /dev/null
+// { dg-options "-std=gnu++17" }
+// { dg-do compile { target c++17 } }
+
+#include <unordered_map>
+#include <testsuite_allocator.h>
+
+using __gnu_test::SimpleAllocator;
+
+static_assert(std::is_same_v<
+ decltype(std::unordered_map{std::pair{1, 2.0},
+ {2, 3.0}, {3, 4.0}}),
+ std::unordered_map<int, double>>);
+
+static_assert(std::is_same_v<
+ decltype(std::unordered_map{{std::pair{1, 2.0},
+ {2, 3.0}, {3, 4.0}}}),
+ std::unordered_map<int, double>>);
+
+static_assert(std::is_same_v<
+ decltype(std::unordered_map{{std::pair{1, 2.0},
+ {2, 3.0}, {3, 4.0}},
+ {}, std::hash<int>{}, {}}),
+ std::unordered_map<int, double>>);
+
+static_assert(std::is_same_v<
+ decltype(std::unordered_map{{std::pair{1, 2.0},
+ {2, 3.0}, {3, 4.0}},
+ {}}),
+ std::unordered_map<int, double>>);
+
+static_assert(std::is_same_v<
+ decltype(std::unordered_map{{std::pair{1, 2.0},
+ {2, 3.0}, {3, 4.0}},
+ {}, {}, {},
+ SimpleAllocator<std::pair<const int, double>>{}}),
+ std::unordered_map<int, double, std::hash<int>,
+ std::equal_to<int>,
+ SimpleAllocator<std::pair<const int, double>>>>);
+
+
+void f()
+{
+ std::unordered_map<int, double> x;
+ static_assert(std::is_same_v<
+ decltype(std::unordered_map(x.begin(), x.end())),
+ std::unordered_map<int, double>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::unordered_map{x.begin(), x.end(),
+ {}, std::hash<int>{}, {},
+ std::allocator<std::pair<const int, double>>{}}),
+ std::unordered_map<int, double>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::unordered_map{x.begin(), x.end(),
+ {}, std::hash<int>{}, {}}),
+ std::unordered_map<int, double>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::unordered_map(x.begin(), x.end(),
+ {})),
+ std::unordered_map<int, double>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::unordered_map{x.begin(), x.end(),
+ {}, {}, {},
+ std::allocator<std::pair<const int, double>>{}}),
+ std::unordered_map<int, double>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::unordered_map{x.begin(), x.end(),
+ {}, {}, {},
+ SimpleAllocator<std::pair<const int, double>>{}}),
+ std::unordered_map<int, double, std::hash<int>,
+ std::equal_to<int>,
+ SimpleAllocator<std::pair<const int, double>>>>);
+}
--- /dev/null
+// { dg-options "-std=gnu++17" }
+// { dg-do compile { target c++17 } }
+
+#include <unordered_map>
+#include <testsuite_allocator.h>
+
+using __gnu_test::SimpleAllocator;
+
+static_assert(std::is_same_v<
+ decltype(std::unordered_multimap{std::pair{1, 2.0},
+ {2, 3.0}, {3, 4.0}}),
+ std::unordered_multimap<int, double>>);
+
+static_assert(std::is_same_v<
+ decltype(std::unordered_multimap{{std::pair{1, 2.0},
+ {2, 3.0}, {3, 4.0}}}),
+ std::unordered_multimap<int, double>>);
+
+static_assert(std::is_same_v<
+ decltype(std::unordered_multimap{{std::pair{1, 2.0},
+ {2, 3.0}, {3, 4.0}},
+ {}, std::hash<int>{}, {}}),
+ std::unordered_multimap<int, double>>);
+
+static_assert(std::is_same_v<
+ decltype(std::unordered_multimap{{std::pair{1, 2.0},
+ {2, 3.0}, {3, 4.0}},
+ {}}),
+ std::unordered_multimap<int, double>>);
+
+static_assert(std::is_same_v<
+ decltype(std::unordered_multimap{{std::pair{1, 2.0},
+ {2, 3.0}, {3, 4.0}},
+ {}, {}, {},
+ SimpleAllocator<std::pair<const int, double>>{}}),
+ std::unordered_multimap<int, double, std::hash<int>,
+ std::equal_to<int>,
+ SimpleAllocator<std::pair<const int, double>>>>);
+
+
+void f()
+{
+ std::unordered_multimap<int, double> x;
+ static_assert(std::is_same_v<
+ decltype(std::unordered_multimap(x.begin(), x.end())),
+ std::unordered_multimap<int, double>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::unordered_multimap{x.begin(), x.end(),
+ {}, std::hash<int>{}, {},
+ std::allocator<std::pair<const int, double>>{}}),
+ std::unordered_multimap<int, double>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::unordered_multimap{x.begin(), x.end(),
+ {}, std::hash<int>{}, {}}),
+ std::unordered_multimap<int, double>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::unordered_multimap(x.begin(), x.end(),
+ {})),
+ std::unordered_multimap<int, double>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::unordered_multimap{x.begin(), x.end(),
+ {}, {}, {},
+ std::allocator<std::pair<const int, double>>{}}),
+ std::unordered_multimap<int, double>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::unordered_multimap{x.begin(), x.end(),
+ {}, {}, {},
+ SimpleAllocator<std::pair<const int, double>>{}}),
+ std::unordered_multimap<int, double, std::hash<int>,
+ std::equal_to<int>,
+ SimpleAllocator<std::pair<const int, double>>>>);
+}
--- /dev/null
+// { dg-options "-std=gnu++17" }
+// { dg-do compile { target c++17 } }
+
+#include <unordered_set>
+#include <testsuite_allocator.h>
+
+using __gnu_test::SimpleAllocator;
+
+static_assert(std::is_same_v<
+ decltype(std::unordered_multiset{1, 2, 3}),
+ std::unordered_multiset<int>>);
+
+static_assert(std::is_same_v<
+ decltype(std::unordered_multiset{1, 2, 3}),
+ std::unordered_multiset<int>>);
+
+static_assert(std::is_same_v<
+ decltype(std::unordered_multiset{{1, 2, 3},
+ 0, std::hash<int>{}, {}}),
+ std::unordered_multiset<int>>);
+
+static_assert(std::is_same_v<
+ decltype(std::unordered_multiset{{1, 2, 3},
+ {}}),
+ std::unordered_multiset<int>>);
+
+static_assert(std::is_same_v<
+ decltype(std::unordered_multiset{{1, 2, 3},
+ {}, {}, {}, std::allocator<int>{}}),
+ std::unordered_multiset<int>>);
+
+static_assert(std::is_same_v<
+ decltype(std::unordered_multiset{{1, 2, 3},
+ {}, {}, {}, SimpleAllocator<int>{}}),
+ std::unordered_multiset<int, std::hash<int>,
+ std::equal_to<int>,
+ SimpleAllocator<int>>>);
+
+void f()
+{
+ std::unordered_multiset<int> x;
+
+ static_assert(std::is_same_v<
+ decltype(std::unordered_multiset(x.begin(), x.end())),
+ std::unordered_multiset<int>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::unordered_multiset{x.begin(), x.end(),
+ {},
+ std::hash<int>{},
+ std::equal_to<int>{},
+ std::allocator<int>{}}),
+ std::unordered_multiset<int>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::unordered_multiset{x.begin(), x.end(),
+ {}, std::hash<int>{}, {}}),
+ std::unordered_multiset<int>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::unordered_multiset(x.begin(), x.end(),
+ {})),
+ std::unordered_multiset<int>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::unordered_multiset{x.begin(), x.end(),
+ {}, {}, {},
+ std::allocator<int>{}}),
+ std::unordered_multiset<int>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::unordered_multiset{x.begin(), x.end(),
+ {}, {}, {},
+ SimpleAllocator<int>{}}),
+ std::unordered_multiset<int, std::hash<int>,
+ std::equal_to<int>,
+ SimpleAllocator<int>>>);
+}
--- /dev/null
+// { dg-options "-std=gnu++17" }
+// { dg-do compile { target c++17 } }
+
+#include <unordered_set>
+#include <testsuite_allocator.h>
+
+using __gnu_test::SimpleAllocator;
+
+static_assert(std::is_same_v<
+ decltype(std::unordered_set{1, 2, 3}),
+ std::unordered_set<int>>);
+
+static_assert(std::is_same_v<
+ decltype(std::unordered_set{1, 2, 3}),
+ std::unordered_set<int>>);
+
+static_assert(std::is_same_v<
+ decltype(std::unordered_set{{1, 2, 3},
+ 0, std::hash<int>{}, {}}),
+ std::unordered_set<int>>);
+
+static_assert(std::is_same_v<
+ decltype(std::unordered_set{{1, 2, 3},
+ {}}),
+ std::unordered_set<int>>);
+
+static_assert(std::is_same_v<
+ decltype(std::unordered_set{{1, 2, 3},
+ {}, {}, {}, std::allocator<int>{}}),
+ std::unordered_set<int>>);
+
+static_assert(std::is_same_v<
+ decltype(std::unordered_set{{1, 2, 3},
+ {}, {}, {}, SimpleAllocator<int>{}}),
+ std::unordered_set<int, std::hash<int>,
+ std::equal_to<int>,
+ SimpleAllocator<int>>>);
+
+void f()
+{
+ std::unordered_set<int> x;
+
+ static_assert(std::is_same_v<
+ decltype(std::unordered_set(x.begin(), x.end())),
+ std::unordered_set<int>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::unordered_set{x.begin(), x.end(),
+ {},
+ std::hash<int>{},
+ std::equal_to<int>{},
+ std::allocator<int>{}}),
+ std::unordered_set<int>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::unordered_set{x.begin(), x.end(),
+ {}, std::hash<int>{}, {}}),
+ std::unordered_set<int>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::unordered_set(x.begin(), x.end(),
+ {})),
+ std::unordered_set<int>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::unordered_set{x.begin(), x.end(),
+ {}, {}, {},
+ std::allocator<int>{}}),
+ std::unordered_set<int>>);
+
+ static_assert(std::is_same_v<
+ decltype(std::unordered_set{x.begin(), x.end(),
+ {}, {}, {},
+ SimpleAllocator<int>{}}),
+ std::unordered_set<int, std::hash<int>,
+ std::equal_to<int>,
+ SimpleAllocator<int>>>);
+}
projects / gcc.git / commitdiff