Re: [PATCH v3] libstdc++: Mark <queue>, <deque> constexpr
Tomasz Kaminski <[email protected]> Thu, 6 Aug 2026 13:15:10 +0200
| Newsgroups | gmane.comp.gcc.patches,gmane.comp.gcc.libstdc++.devel |
|---|---|
| Message-ID | <CAKvuMXCJb66DjXRUew7QzT5d2F45oQGuFHWeehXc7rvrY0Nz9w@mail.gmail.com> |
On Thu, Aug 6, 2026 at 12:28 PM Tomasz Kamiński <[email protected]> wrote: > This patch makes partial progress towards P3372 by marking deque, queue, > and relevant internal helpers to be constexpr when using C++26 > (priority_queue was made constexr by r17-1233-g5a6ae2b286a730). > > For debug version we use similar approach as is used for vector in > r14-6553-g7d00a59229ee17, and disable safe iterator instrumentation > and checking during constant evaluation, because of mutex locks > and call to non-inline functions. > > The __uninitialized_default_a overloads that do not depend on > _Deque_iterator, are marked as _GLIBCXX20_CONSTEXPR for that reason. > > libstdc++-v3/ChangeLog: > > * include/bits/deque.tcc (deque): Declare out of line member > defintions as _GLIBCXX26_CONSTEXPR. > (std::__fill_a1, std::__copy_move_dit, std::__copy_move_a1) > (std::__copy_move_a2, std::__copy_n_a) > (std::__copy_move_backward_dit, std::__copy_move_backward_a1) > (std::__equal_dit, std::__equal_aux1, std::__lex_cmp_dit) > (std::__lexicographical_compare_aux1, std::__uninitialized_copy_a) > (std::__uninitialized_move_a): Declare as _GLIBCXX26_CONSTEXPR. > * include/bits/stl_algobase.h (std::__fill_a1, std::__copy_n_a) > (std::__copy_move_a1, std::__copy_move_backward_a1) > (std::__equal_aux1, __lexicographical_compare_aux1): Declare > overloads accepting _Deque_iterator as _GLIBCXX26_CONSTEXPR. > * include/bits/stl_deque.h (std::_Deque_iterator, std::_Deque_base) > (std::deque): Declare members as _GLIBCXX26_CONSTEXPR. > (std::operator==, std::operator<=>, std::swap): Declare as > _GLIBCXX26_CONSTEXPR. > * include/bits/stl_queue.h (std::queue): Declare members as > _GLIBCXX26_CONSTEXPR. > (std::priority_queue): Make _GLIBCXX26_CONSTEXPR placement > consistient. > (std::operator==, std::operator!=, std::operator<, std::operator>) > (std::operator<=, std::operator>=, std::operator<=>, std::swap): > Declare as _GLIBCXX26_CONSTEXPR. > * include/bits/stl_uninitialized.h (std::__uninitialized_copy_a): > Declare overloads accepting _Deque_iterator as > _GLIBCXX26_CONSTEXPR. > (std::__uninitialized_default_a): Declare as _GLIBCXX20_CONSTEXPR. > * include/bits/version.def (constexpr_deque, constexpr_queue): > Define. > * include/bits/version.h: Regenerate. > * include/debug/deque (__debug::deque): Declare members as > _GLIBCXX26_CONSTEXPR. > (__debug::operator==, __debug::operator<=>, __debug::swap) > (__debug::erase, __debug::__erase_if): Declare as > _GLIBCXX26_CONSTEXPR. > * include/std/deque (__cpp_lib_constexpr_deque): Define. > (std::erase, std::erase_if): Declare as _GLIBCXX26_CONSTEXPR. > * include/std/queue (__cpp_lib_constexpr_queue): Define. > (_GLIBCXX_CONSTEXPR_FORMAT): Define locally. > (std::formatter<priority_queue<...>, _CharT>::format) > (std::formatter<queue<...>, _CharT>::format): Declare as > _GLIBCXX_CONSTEXPR_FORMAT. > * testsuite/23_containers/deque/constexpr.cc: New test. > * testsuite/23_containers/headers/deque/synopsis.cc: Updated > declarations. > Forgotten to squash equivalent changes to testsuite/23_containers/headers/queue/synopsis.c. Added them locally. > * testsuite/23_containers/queue/constexpr.cc: New test. > * testsuite/23_containers/priority_queue/constexpr.cc: Replace > existing test with expanded suite. > * testsuite/std/format/ranges/adaptors.cc: Test at compile > time. > > Co-authored-by: Thor Preimesberger <[email protected]> > Signed-off-by: Thor Preimesberger <[email protected]> > Signed-off-by: Tomasz Kamiński <[email protected]> > --- > v3 is recreation of previous patch, as (most likely due mailing > client) all tabs were removed, making it impossible to apply. > I was able to reuse the additional tests. > > v3: > - rebases the priority_queue changes, as it was merged > - provides proper support for debug::deque in constexpr, > by disabling the checks (as for vector) > - expand the patch to cover cosntexpr formatting of the > containers, as it was merged. > - updates test a bit, to use separate static_assert, > and have more consistient formatting. > > Tested on x86_64-linx and testing on powerpc64-le. > All 23_containers/*ue* and format/ranges/adaptors.cc test > passed in all standard modes, -m32, debug and assertions. > OK for trunk when all test passes? > > libstdc++-v3/include/bits/deque.tcc | 97 +++-- > libstdc++-v3/include/bits/stl_algobase.h | 22 +- > libstdc++-v3/include/bits/stl_deque.h | 363 ++++++++++-------- > libstdc++-v3/include/bits/stl_queue.h | 107 +++--- > libstdc++-v3/include/bits/stl_uninitialized.h | 7 +- > libstdc++-v3/include/bits/version.def | 18 + > libstdc++-v3/include/bits/version.h | 20 + > libstdc++-v3/include/debug/deque | 210 ++++++---- > libstdc++-v3/include/std/deque | 7 +- > libstdc++-v3/include/std/queue | 11 + > .../23_containers/deque/constexpr.cc | 334 ++++++++++++++++ > .../23_containers/headers/deque/synopsis.cc | 26 +- > .../23_containers/priority_queue/constexpr.cc | 253 ++++++++++-- > .../23_containers/queue/constexpr.cc | 242 ++++++++++++ > .../testsuite/std/format/ranges/adaptors.cc | 34 +- > 15 files changed, 1370 insertions(+), 381 deletions(-) > create mode 100644 libstdc++-v3/testsuite/23_containers/deque/constexpr.cc > create mode 100644 libstdc++-v3/testsuite/23_containers/queue/constexpr.cc > > diff --git a/libstdc++-v3/include/bits/deque.tcc > b/libstdc++-v3/include/bits/deque.tcc > index df4be080212..cf260a5269c 100644 > --- a/libstdc++-v3/include/bits/deque.tcc > +++ b/libstdc++-v3/include/bits/deque.tcc > @@ -65,7 +65,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > > #if __cplusplus >= 201103L > template <typename _Tp, typename _Alloc> > - void > + _GLIBCXX26_CONSTEXPR void > deque<_Tp, _Alloc>:: > _M_default_initialize() > { > @@ -91,6 +91,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > #endif > > template <typename _Tp, typename _Alloc> > + _GLIBCXX26_CONSTEXPR > deque<_Tp, _Alloc>& > deque<_Tp, _Alloc>:: > operator=(const deque& __x) > @@ -133,6 +134,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > template<typename _Tp, typename _Alloc> > template<typename... _Args> > #if __cplusplus > 201402L > + _GLIBCXX26_CONSTEXPR > typename deque<_Tp, _Alloc>::reference > #else > void > @@ -157,6 +159,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > template<typename _Tp, typename _Alloc> > template<typename... _Args> > #if __cplusplus > 201402L > + _GLIBCXX26_CONSTEXPR > typename deque<_Tp, _Alloc>::reference > #else > void > @@ -183,6 +186,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > #if __cplusplus >= 201103L > template<typename _Tp, typename _Alloc> > template<typename... _Args> > + _GLIBCXX26_CONSTEXPR > typename deque<_Tp, _Alloc>::iterator > deque<_Tp, _Alloc>:: > emplace(const_iterator __position, _Args&&... __args) > @@ -206,6 +210,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > #endif > > template <typename _Tp, typename _Alloc> > + _GLIBCXX26_CONSTEXPR > typename deque<_Tp, _Alloc>::iterator > deque<_Tp, _Alloc>:: > #if __cplusplus >= 201103L > @@ -231,6 +236,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > } > > template <typename _Tp, typename _Alloc> > + _GLIBCXX26_CONSTEXPR > typename deque<_Tp, _Alloc>::iterator > deque<_Tp, _Alloc>:: > _M_erase(iterator __position) > @@ -254,6 +260,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > } > > template <typename _Tp, typename _Alloc> > + _GLIBCXX26_CONSTEXPR > typename deque<_Tp, _Alloc>::iterator > deque<_Tp, _Alloc>:: > _M_erase(iterator __first, iterator __last) > @@ -287,7 +294,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > > template <typename _Tp, class _Alloc> > template <typename _InputIterator> > - void > + _GLIBCXX26_CONSTEXPR void > deque<_Tp, _Alloc>:: > _M_assign_aux(_InputIterator __first, _InputIterator __last, > std::input_iterator_tag) > @@ -303,7 +310,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > } > > template <typename _Tp, typename _Alloc> > - void > + _GLIBCXX26_CONSTEXPR void > deque<_Tp, _Alloc>:: > _M_fill_insert(iterator __pos, size_type __n, const value_type& __x) > { > @@ -346,7 +353,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > > #if __cplusplus >= 201103L > template <typename _Tp, typename _Alloc> > - void > + _GLIBCXX26_CONSTEXPR void > deque<_Tp, _Alloc>:: > _M_default_append(size_type __n) > { > @@ -370,7 +377,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > } > > template <typename _Tp, typename _Alloc> > - bool > + _GLIBCXX26_CONSTEXPR bool > deque<_Tp, _Alloc>:: > _M_shrink_to_fit() > { > @@ -389,7 +396,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > #endif > > template <typename _Tp, typename _Alloc> > - void > + _GLIBCXX26_CONSTEXPR void > deque<_Tp, _Alloc>:: > _M_fill_initialize(const value_type& __value) > { > @@ -415,7 +422,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > > template <typename _Tp, typename _Alloc> > template <typename _InputIterator> > - void > + _GLIBCXX26_CONSTEXPR void > deque<_Tp, _Alloc>:: > _M_range_initialize(_InputIterator __first, _InputIterator __last, > std::input_iterator_tag) > @@ -439,7 +446,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > > template <typename _Tp, typename _Alloc> > template <typename _ForwardIterator> > - void > + _GLIBCXX26_CONSTEXPR void > deque<_Tp, _Alloc>:: > _M_range_initialize(_ForwardIterator __first, _ForwardIterator > __last, > std::forward_iterator_tag) > @@ -480,7 +487,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > template<typename _Tp, typename _Alloc> > #if __cplusplus >= 201103L > template<typename... _Args> > - void > + _GLIBCXX26_CONSTEXPR void > deque<_Tp, _Alloc>:: > _M_push_back_aux(_Args&&... __args) > #else > @@ -519,7 +526,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > template<typename _Tp, typename _Alloc> > #if __cplusplus >= 201103L > template<typename... _Args> > - void > + _GLIBCXX26_CONSTEXPR void > deque<_Tp, _Alloc>:: > _M_push_front_aux(_Args&&... __args) > #else > @@ -557,7 +564,8 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > > // Called only if _M_impl._M_finish._M_cur == > _M_impl._M_finish._M_first. > template <typename _Tp, typename _Alloc> > - void deque<_Tp, _Alloc>:: > + _GLIBCXX26_CONSTEXPR void > + deque<_Tp, _Alloc>:: > _M_pop_back_aux() > { > _M_deallocate_node(this->_M_impl._M_finish._M_first); > @@ -573,7 +581,8 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > // _M_impl._M_start._M_cur == _M_impl._M_start._M_last, > // then the deque must have at least two nodes. > template <typename _Tp, typename _Alloc> > - void deque<_Tp, _Alloc>:: > + _GLIBCXX26_CONSTEXPR void > + deque<_Tp, _Alloc>:: > _M_pop_front_aux() > { > _Alloc_traits::destroy(_M_get_Tp_allocator(), > @@ -585,7 +594,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > > template <typename _Tp, typename _Alloc> > template <typename _InputIterator, typename _Sentinel> > - void > + _GLIBCXX26_CONSTEXPR void > deque<_Tp, _Alloc>:: > _M_range_prepend(_InputIterator __first, _Sentinel __last, > size_type __n) > @@ -607,7 +616,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > > template <typename _Tp, typename _Alloc> > template <typename _InputIterator, typename _Sentinel> > - void > + _GLIBCXX26_CONSTEXPR void > deque<_Tp, _Alloc>:: > _M_range_append(_InputIterator __first, _Sentinel __last, > size_type __n) > @@ -630,7 +639,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > > template <typename _Tp, typename _Alloc> > template <typename _InputIterator> > - void > + _GLIBCXX26_CONSTEXPR void > deque<_Tp, _Alloc>:: > _M_range_insert_aux(iterator __pos, > _InputIterator __first, _InputIterator __last, > @@ -639,7 +648,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > > template <typename _Tp, typename _Alloc> > template <typename _ForwardIterator> > - void > + _GLIBCXX26_CONSTEXPR void > deque<_Tp, _Alloc>:: > _M_range_insert_aux(iterator __pos, > _ForwardIterator __first, _ForwardIterator > __last, > @@ -660,6 +669,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > template<typename _Tp, typename _Alloc> > #if __cplusplus >= 201103L > template<typename... _Args> > + _GLIBCXX26_CONSTEXPR > typename deque<_Tp, _Alloc>::iterator > deque<_Tp, _Alloc>:: > _M_emplace_aux(iterator __pos, _Args&&... __args) > @@ -707,7 +717,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > } > > template <typename _Tp, typename _Alloc> > - void > + _GLIBCXX26_CONSTEXPR void > deque<_Tp, _Alloc>:: > _M_insert_aux(iterator __pos, size_type __n, const value_type& __x) > { > @@ -793,7 +803,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > > template <typename _Tp, typename _Alloc> > template <typename _ForwardIterator> > - void > + _GLIBCXX26_CONSTEXPR void > deque<_Tp, _Alloc>:: > _M_insert_aux(iterator __pos, > _ForwardIterator __first, _ForwardIterator __last, > @@ -882,7 +892,8 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > > #if __glibcxx_containers_ranges // C++ >= 23 > template<ranges::forward_range _Rg> > - auto __advance_dist(_Rg& __rg) > + _GLIBCXX26_CONSTEXPR auto > + __advance_dist(_Rg& __rg) > { > struct _Res > { > @@ -914,7 +925,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > > template<typename _Tp, typename _Alloc> > template<__detail::__container_compatible_range<_Tp> _Rg> > - auto > + _GLIBCXX26_CONSTEXPR auto > deque<_Tp, _Alloc>:: > insert_range(const_iterator __pos, _Rg&& __rg) > -> iterator > @@ -954,7 +965,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > > template<typename _Tp, typename _Alloc> > template<__detail::__container_compatible_range<_Tp> _Rg> > - void > + _GLIBCXX26_CONSTEXPR void > deque<_Tp, _Alloc>:: > prepend_range(_Rg&& __rg) > { > @@ -996,7 +1007,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > > template<typename _Tp, typename _Alloc> > template<__detail::__container_compatible_range<_Tp> _Rg> > - void > + _GLIBCXX26_CONSTEXPR void > deque<_Tp, _Alloc>:: > append_range(_Rg&& __rg) > { > @@ -1013,6 +1024,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > deque& __self; > size_type __n = __self.size(); > > + _GLIBCXX26_CONSTEXPR > ~_Guard_elts_back() > { > if (__n < __self.size()) > @@ -1032,7 +1044,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > #endif // containers_ranges > > template<typename _Tp, typename _Alloc> > - void > + _GLIBCXX26_CONSTEXPR void > deque<_Tp, _Alloc>:: > _M_destroy_data_aux(iterator __first, iterator __last) > { > @@ -1054,7 +1066,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > } > > template <typename _Tp, typename _Alloc> > - void > + _GLIBCXX26_CONSTEXPR void > deque<_Tp, _Alloc>:: > _M_new_elements_at_front(size_type __new_elems) > { > @@ -1079,7 +1091,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > } > > template <typename _Tp, typename _Alloc> > - void > + _GLIBCXX26_CONSTEXPR void > deque<_Tp, _Alloc>:: > _M_new_elements_at_back(size_type __new_elems) > { > @@ -1104,7 +1116,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > } > > template <typename _Tp, typename _Alloc> > - void > + _GLIBCXX26_CONSTEXPR void > deque<_Tp, _Alloc>:: > _M_reallocate_map(size_type __nodes_to_add, bool __add_at_front) > { > @@ -1158,7 +1170,7 @@ _GLIBCXX_END_NAMESPACE_CONTAINER > // Overload for deque::iterators, exploiting the "segmented-iterator > // optimization". > template<typename _Tp, typename _VTp> > - void > + _GLIBCXX26_CONSTEXPR void > __fill_a1(const _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>& > __first, > const _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>& > __last, > const _VTp& __value) > @@ -1180,7 +1192,7 @@ _GLIBCXX_END_NAMESPACE_CONTAINER > > template<bool _IsMove, > typename _Tp, typename _Ref, typename _Ptr, typename _OI> > - _OI > + _GLIBCXX26_CONSTEXPR _OI > __copy_move_dit(_GLIBCXX_STD_C::_Deque_iterator<_Tp, _Ref, _Ptr> > __first, > _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Ref, _Ptr> > __last, > _OI __result) > @@ -1209,7 +1221,7 @@ _GLIBCXX_END_NAMESPACE_CONTAINER > > template<bool _IsMove, > typename _Tp, typename _Ref, typename _Ptr, typename _OI> > - _OI > + _GLIBCXX26_CONSTEXPR _OI > __copy_move_a1(_GLIBCXX_STD_C::_Deque_iterator<_Tp, _Ref, _Ptr> > __first, > _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Ref, _Ptr> __last, > _OI __result) > @@ -1217,6 +1229,7 @@ _GLIBCXX_END_NAMESPACE_CONTAINER > > template<bool _IsMove, > typename _ITp, typename _IRef, typename _IPtr, typename _OTp> > + _GLIBCXX26_CONSTEXPR > _GLIBCXX_STD_C::_Deque_iterator<_OTp, _OTp&, _OTp*> > __copy_move_a1(_GLIBCXX_STD_C::_Deque_iterator<_ITp, _IRef, _IPtr> > __first, > _GLIBCXX_STD_C::_Deque_iterator<_ITp, _IRef, _IPtr> > __last, > @@ -1224,6 +1237,7 @@ _GLIBCXX_END_NAMESPACE_CONTAINER > { return __copy_move_dit<_IsMove>(__first, __last, __result); } > > template<bool _IsMove, typename _II, typename _Tp> > + _GLIBCXX26_CONSTEXPR > typename __gnu_cxx::__enable_if< > __is_any_random_access_iter<_II>::__value, > _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type > @@ -1250,6 +1264,7 @@ _GLIBCXX_END_NAMESPACE_CONTAINER > } > > template<bool _IsMove, typename _CharT> > + _GLIBCXX26_CONSTEXPR > typename __gnu_cxx::__enable_if< > __is_char<_CharT>::__value, > _GLIBCXX_STD_C::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type > @@ -1277,6 +1292,7 @@ _GLIBCXX_END_NAMESPACE_CONTAINER > } > > template<typename _CharT, typename _Size> > + _GLIBCXX26_CONSTEXPR > typename __gnu_cxx::__enable_if< > __is_char<_CharT>::__value, > _GLIBCXX_STD_C::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type > @@ -1302,7 +1318,7 @@ _GLIBCXX_END_NAMESPACE_CONTAINER > > template<bool _IsMove, > typename _Tp, typename _Ref, typename _Ptr, typename _OI> > - _OI > + _GLIBCXX26_CONSTEXPR _OI > __copy_move_backward_dit( > _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Ref, _Ptr> __first, > _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Ref, _Ptr> __last, > @@ -1329,7 +1345,7 @@ _GLIBCXX_END_NAMESPACE_CONTAINER > > template<bool _IsMove, > typename _Tp, typename _Ref, typename _Ptr, typename _OI> > - _OI > + _GLIBCXX26_CONSTEXPR _OI > __copy_move_backward_a1( > _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Ref, _Ptr> __first, > _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Ref, _Ptr> __last, > @@ -1338,6 +1354,7 @@ _GLIBCXX_END_NAMESPACE_CONTAINER > > template<bool _IsMove, > typename _ITp, typename _IRef, typename _IPtr, typename _OTp> > + _GLIBCXX26_CONSTEXPR > _GLIBCXX_STD_C::_Deque_iterator<_OTp, _OTp&, _OTp*> > __copy_move_backward_a1( > _GLIBCXX_STD_C::_Deque_iterator<_ITp, _IRef, _IPtr> > __first, > @@ -1346,6 +1363,7 @@ _GLIBCXX_END_NAMESPACE_CONTAINER > { return __copy_move_backward_dit<_IsMove>(__first, __last, > __result); } > > template<bool _IsMove, typename _II, typename _Tp> > + _GLIBCXX26_CONSTEXPR > typename __gnu_cxx::__enable_if< > __is_any_random_access_iter<_II>::__value, > _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type > @@ -1378,7 +1396,7 @@ _GLIBCXX_END_NAMESPACE_CONTAINER > } > > template<typename _Tp, typename _Ref, typename _Ptr, typename _II> > - bool > + _GLIBCXX26_CONSTEXPR bool > __equal_dit( > const _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Ref, _Ptr>& __first1, > const _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Ref, _Ptr>& __last1, > @@ -1405,6 +1423,7 @@ _GLIBCXX_END_NAMESPACE_CONTAINER > } > > template<typename _Tp, typename _Ref, typename _Ptr, typename _II> > + _GLIBCXX26_CONSTEXPR > typename __gnu_cxx::__enable_if< > __is_any_random_access_iter<_II>::__value, bool>::__type > __equal_aux1(_GLIBCXX_STD_C::_Deque_iterator<_Tp, _Ref, _Ptr> > __first1, > @@ -1414,13 +1433,14 @@ _GLIBCXX_END_NAMESPACE_CONTAINER > > template<typename _Tp1, typename _Ref1, typename _Ptr1, > typename _Tp2, typename _Ref2, typename _Ptr2> > - bool > + _GLIBCXX26_CONSTEXPR bool > __equal_aux1(_GLIBCXX_STD_C::_Deque_iterator<_Tp1, _Ref1, _Ptr1> > __first1, > _GLIBCXX_STD_C::_Deque_iterator<_Tp1, _Ref1, _Ptr1> > __last1, > _GLIBCXX_STD_C::_Deque_iterator<_Tp2, _Ref2, _Ptr2> > __first2) > { return std::__equal_dit(__first1, __last1, __first2); } > > template<typename _II, typename _Tp, typename _Ref, typename _Ptr> > + _GLIBCXX26_CONSTEXPR > typename __gnu_cxx::__enable_if< > __is_any_random_access_iter<_II>::__value, bool>::__type > __equal_aux1(_II __first1, _II __last1, > @@ -1446,7 +1466,7 @@ _GLIBCXX_END_NAMESPACE_CONTAINER > } > > template<typename _Tp1, typename _Ref, typename _Ptr, typename _Tp2> > - int > + _GLIBCXX26_CONSTEXPR int > __lex_cmp_dit( > _GLIBCXX_STD_C::_Deque_iterator<_Tp1, _Ref, _Ptr> __first1, > _GLIBCXX_STD_C::_Deque_iterator<_Tp1, _Ref, _Ptr> __last1, > @@ -1487,7 +1507,7 @@ _GLIBCXX_END_NAMESPACE_CONTAINER > > template<typename _Tp1, typename _Ref1, typename _Ptr1, > typename _Tp2> > - inline bool > + inline _GLIBCXX26_CONSTEXPR bool > __lexicographical_compare_aux1( > _GLIBCXX_STD_C::_Deque_iterator<_Tp1, _Ref1, _Ptr1> __first1, > _GLIBCXX_STD_C::_Deque_iterator<_Tp1, _Ref1, _Ptr1> __last1, > @@ -1496,7 +1516,7 @@ _GLIBCXX_END_NAMESPACE_CONTAINER > > template<typename _Tp1, > typename _Tp2, typename _Ref2, typename _Ptr2> > - inline bool > + inline _GLIBCXX26_CONSTEXPR bool > __lexicographical_compare_aux1(_Tp1* __first1, _Tp1* __last1, > _GLIBCXX_STD_C::_Deque_iterator<_Tp2, _Ref2, _Ptr2> __first2, > _GLIBCXX_STD_C::_Deque_iterator<_Tp2, _Ref2, _Ptr2> __last2) > @@ -1504,7 +1524,7 @@ _GLIBCXX_END_NAMESPACE_CONTAINER > > template<typename _Tp1, typename _Ref1, typename _Ptr1, > typename _Tp2, typename _Ref2, typename _Ptr2> > - inline bool > + inline _GLIBCXX26_CONSTEXPR bool > __lexicographical_compare_aux1( > _GLIBCXX_STD_C::_Deque_iterator<_Tp1, _Ref1, _Ptr1> > __first1, > _GLIBCXX_STD_C::_Deque_iterator<_Tp1, _Ref1, _Ptr1> > __last1, > @@ -1554,6 +1574,7 @@ _GLIBCXX_END_NAMESPACE_CONTAINER > #pragma GCC diagnostic ignored "-Wc++17-extensions" // if constexpr > template<typename _ITp, typename _IRef, typename _IPtr, typename _OTp, > typename _Tp> > + _GLIBCXX26_CONSTEXPR > _GLIBCXX_STD_C::_Deque_iterator<_OTp, _OTp&, _OTp*> > __uninitialized_copy_a( > _GLIBCXX_STD_C::_Deque_iterator<_ITp, _IRef, _IPtr> __first, > @@ -1583,6 +1604,7 @@ _GLIBCXX_END_NAMESPACE_CONTAINER > } > > template<typename _Iter, typename _OTp, typename _Tp> > + _GLIBCXX26_CONSTEXPR > __enable_if_t<__is_random_access_iter<_Iter>::value, > _GLIBCXX_STD_C::_Deque_iterator<_OTp, _OTp&, _OTp*>> > __uninitialized_copy_a(_Iter __first, _Iter __last, > @@ -1607,6 +1629,7 @@ _GLIBCXX_END_NAMESPACE_CONTAINER > > template<typename _ITp, typename _IRef, typename _IPtr, typename _OTp, > typename _Tp> > + _GLIBCXX26_CONSTEXPR > _GLIBCXX_STD_C::_Deque_iterator<_OTp, _OTp&, _OTp*> > __uninitialized_move_a( > _GLIBCXX_STD_C::_Deque_iterator<_ITp, _IRef, _IPtr> __first, > diff --git a/libstdc++-v3/include/bits/stl_algobase.h > b/libstdc++-v3/include/bits/stl_algobase.h > index 33b1177810a..1df48418c42 100644 > --- a/libstdc++-v3/include/bits/stl_algobase.h > +++ b/libstdc++-v3/include/bits/stl_algobase.h > @@ -347,6 +347,7 @@ _GLIBCXX_END_NAMESPACE_CONTAINER > istreambuf_iterator<_CharT, char_traits<_CharT> >, > _CharT*); > > template<bool _IsMove, typename _CharT> > + _GLIBCXX26_CONSTEXPR > typename __gnu_cxx::__enable_if< > __is_char<_CharT>::__value, > _GLIBCXX_STD_C::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type > @@ -464,19 +465,21 @@ _GLIBCXX_END_NAMESPACE_CONTAINER > > template<bool _IsMove, > typename _Tp, typename _Ref, typename _Ptr, typename _OI> > - _OI > + _GLIBCXX26_CONSTEXPR _OI > __copy_move_a1(_GLIBCXX_STD_C::_Deque_iterator<_Tp, _Ref, _Ptr>, > _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Ref, _Ptr>, > _OI); > > template<bool _IsMove, > typename _ITp, typename _IRef, typename _IPtr, typename _OTp> > + _GLIBCXX26_CONSTEXPR > _GLIBCXX_STD_C::_Deque_iterator<_OTp, _OTp&, _OTp*> > __copy_move_a1(_GLIBCXX_STD_C::_Deque_iterator<_ITp, _IRef, _IPtr>, > _GLIBCXX_STD_C::_Deque_iterator<_ITp, _IRef, _IPtr>, > _GLIBCXX_STD_C::_Deque_iterator<_OTp, _OTp&, _OTp*>); > > template<bool _IsMove, typename _II, typename _Tp> > + _GLIBCXX26_CONSTEXPR > typename __gnu_cxx::__enable_if< > __is_any_random_access_iter<_II>::__value, > _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type > @@ -600,6 +603,7 @@ _GLIBCXX_END_NAMESPACE_CONTAINER > _Size, _CharT*, bool); > > template<typename _CharT, typename _Size> > + _GLIBCXX26_CONSTEXPR > typename __gnu_cxx::__enable_if< > __is_char<_CharT>::__value, > _GLIBCXX_STD_C::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type > @@ -752,13 +756,14 @@ _GLIBCXX_END_NAMESPACE_CONTAINER > > template<bool _IsMove, > typename _Tp, typename _Ref, typename _Ptr, typename _OI> > - _OI > + _GLIBCXX26_CONSTEXPR _OI > __copy_move_backward_a1(_GLIBCXX_STD_C::_Deque_iterator<_Tp, _Ref, > _Ptr>, > _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Ref, > _Ptr>, > _OI); > > template<bool _IsMove, > typename _ITp, typename _IRef, typename _IPtr, typename _OTp> > + _GLIBCXX26_CONSTEXPR > _GLIBCXX_STD_C::_Deque_iterator<_OTp, _OTp&, _OTp*> > __copy_move_backward_a1( > _GLIBCXX_STD_C::_Deque_iterator<_ITp, _IRef, > _IPtr>, > @@ -766,6 +771,7 @@ _GLIBCXX_END_NAMESPACE_CONTAINER > _GLIBCXX_STD_C::_Deque_iterator<_OTp, _OTp&, > _OTp*>); > > template<bool _IsMove, typename _II, typename _Tp> > + _GLIBCXX26_CONSTEXPR > typename __gnu_cxx::__enable_if< > __is_any_random_access_iter<_II>::__value, > _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type > @@ -959,7 +965,7 @@ _GLIBCXX_END_NAMESPACE_CONTAINER > { std::__fill_a1(__first.base(), __last.base(), __value); } > > template<typename _Tp, typename _VTp> > - void > + _GLIBCXX26_CONSTEXPR void > __fill_a1(const _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>&, > const _GLIBCXX_STD_C::_Deque_iterator<_Tp, _Tp&, _Tp*>&, > const _VTp&); > @@ -1215,6 +1221,7 @@ _GLIBCXX_END_NAMESPACE_CONTAINER > }; > > template<typename _Tp, typename _Ref, typename _Ptr, typename _II> > + _GLIBCXX26_CONSTEXPR > typename __gnu_cxx::__enable_if< > __is_any_random_access_iter<_II>::__value, bool>::__type > __equal_aux1(_GLIBCXX_STD_C::_Deque_iterator<_Tp, _Ref, _Ptr>, > @@ -1223,12 +1230,13 @@ _GLIBCXX_END_NAMESPACE_CONTAINER > > template<typename _Tp1, typename _Ref1, typename _Ptr1, > typename _Tp2, typename _Ref2, typename _Ptr2> > - bool > + _GLIBCXX26_CONSTEXPR bool > __equal_aux1(_GLIBCXX_STD_C::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, > _GLIBCXX_STD_C::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, > _GLIBCXX_STD_C::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); > > template<typename _II, typename _Tp, typename _Ref, typename _Ptr> > + _GLIBCXX26_CONSTEXPR > typename __gnu_cxx::__enable_if< > __is_any_random_access_iter<_II>::__value, bool>::__type > __equal_aux1(_II, _II, > @@ -1434,7 +1442,7 @@ _GLIBCXX_END_NAMESPACE_CONTAINER > > template<typename _Tp1, typename _Ref1, typename _Ptr1, > typename _Tp2> > - bool > + _GLIBCXX26_CONSTEXPR bool > __lexicographical_compare_aux1( > _GLIBCXX_STD_C::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, > _GLIBCXX_STD_C::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, > @@ -1442,14 +1450,14 @@ _GLIBCXX_END_NAMESPACE_CONTAINER > > template<typename _Tp1, > typename _Tp2, typename _Ref2, typename _Ptr2> > - bool > + _GLIBCXX26_CONSTEXPR bool > __lexicographical_compare_aux1(_Tp1*, _Tp1*, > _GLIBCXX_STD_C::_Deque_iterator<_Tp2, _Ref2, _Ptr2>, > _GLIBCXX_STD_C::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); > > template<typename _Tp1, typename _Ref1, typename _Ptr1, > typename _Tp2, typename _Ref2, typename _Ptr2> > - bool > + _GLIBCXX26_CONSTEXPR bool > __lexicographical_compare_aux1( > _GLIBCXX_STD_C::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, > _GLIBCXX_STD_C::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, > diff --git a/libstdc++-v3/include/bits/stl_deque.h > b/libstdc++-v3/include/bits/stl_deque.h > index b51342e1751..9834787214a 100644 > --- a/libstdc++-v3/include/bits/stl_deque.h > +++ b/libstdc++-v3/include/bits/stl_deque.h > @@ -131,6 +131,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > typedef __ptr_rebind<_Ptr, _Elt_pointer> _Map_pointer; > #endif > > + _GLIBCXX26_CONSTEXPR > static size_t _S_buffer_size() _GLIBCXX_NOEXCEPT > { return __deque_buf_size(sizeof(_Tp)); } > > @@ -147,10 +148,12 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > _Elt_pointer _M_last; > _Map_pointer _M_node; > > + _GLIBCXX26_CONSTEXPR > _Deque_iterator(_Elt_pointer __x, _Map_pointer __y) > _GLIBCXX_NOEXCEPT > : _M_cur(__x), _M_first(*__y), > _M_last(*__y + _S_buffer_size()), _M_node(__y) { } > > + _GLIBCXX26_CONSTEXPR > _Deque_iterator() _GLIBCXX_NOEXCEPT > : _M_cur(), _M_first(), _M_last(), _M_node() { } > > @@ -164,10 +167,12 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > template<typename _Iter, > typename = _Require<is_same<_Self, const_iterator>, > is_same<_Iter, iterator>>> > + _GLIBCXX26_CONSTEXPR > _Deque_iterator(const _Iter& __x) noexcept > : _M_cur(__x._M_cur), _M_first(__x._M_first), > _M_last(__x._M_last), _M_node(__x._M_node) { } > > + _GLIBCXX26_CONSTEXPR > _Deque_iterator(const _Deque_iterator& __x) noexcept > : _M_cur(__x._M_cur), _M_first(__x._M_first), > _M_last(__x._M_last), _M_node(__x._M_node) { } > @@ -175,21 +180,21 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > _Deque_iterator& operator=(const _Deque_iterator&) = default; > #endif > > - iterator > + _GLIBCXX26_CONSTEXPR iterator > _M_const_cast() const _GLIBCXX_NOEXCEPT > { return iterator(_M_cur, _M_node); } > > _GLIBCXX_NODISCARD > - reference > + _GLIBCXX26_CONSTEXPR reference > operator*() const _GLIBCXX_NOEXCEPT > { return *_M_cur; } > > _GLIBCXX_NODISCARD > - pointer > + _GLIBCXX26_CONSTEXPR pointer > operator->() const _GLIBCXX_NOEXCEPT > { return _M_cur; } > > - _Self& > + _GLIBCXX26_CONSTEXPR _Self& > operator++() _GLIBCXX_NOEXCEPT > { > ++_M_cur; > @@ -201,7 +206,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > return *this; > } > > - _Self > + _GLIBCXX26_CONSTEXPR _Self > operator++(int) _GLIBCXX_NOEXCEPT > { > _Self __tmp = *this; > @@ -209,7 +214,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > return __tmp; > } > > - _Self& > + _GLIBCXX26_CONSTEXPR _Self& > operator--() _GLIBCXX_NOEXCEPT > { > if (_M_cur == _M_first) > @@ -221,7 +226,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > return *this; > } > > - _Self > + _GLIBCXX26_CONSTEXPR _Self > operator--(int) _GLIBCXX_NOEXCEPT > { > _Self __tmp = *this; > @@ -229,7 +234,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > return __tmp; > } > > - _Self& > + _GLIBCXX26_CONSTEXPR _Self& > operator+=(difference_type __n) _GLIBCXX_NOEXCEPT > { > const difference_type __offset = __n + (_M_cur - _M_first); > @@ -248,12 +253,12 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > return *this; > } > > - _Self& > + _GLIBCXX26_CONSTEXPR _Self& > operator-=(difference_type __n) _GLIBCXX_NOEXCEPT > { return *this += -__n; } > > _GLIBCXX_NODISCARD > - reference > + _GLIBCXX26_CONSTEXPR reference > operator[](difference_type __n) const _GLIBCXX_NOEXCEPT > { return *(*this + __n); } > > @@ -262,7 +267,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * _M_cur, which should therefore be set by the caller > * immediately afterwards, based on _M_first and _M_last. > */ > - void > + _GLIBCXX26_CONSTEXPR void > _M_set_node(_Map_pointer __new_node) _GLIBCXX_NOEXCEPT > { > _M_node = __new_node; > @@ -271,7 +276,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > } > > _GLIBCXX_NODISCARD > - friend bool > + friend _GLIBCXX26_CONSTEXPR bool > operator==(const _Self& __x, const _Self& __y) _GLIBCXX_NOEXCEPT > { return __x._M_cur == __y._M_cur; } > > @@ -280,7 +285,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > // operators are in scope (for additional details, see > libstdc++/3628) > template<typename _RefR, typename _PtrR> > _GLIBCXX_NODISCARD > - friend bool > + friend _GLIBCXX26_CONSTEXPR bool > operator==(const _Self& __x, > const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) > _GLIBCXX_NOEXCEPT > @@ -288,7 +293,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > > #if __cpp_lib_three_way_comparison > [[nodiscard]] > - friend strong_ordering > + friend _GLIBCXX26_CONSTEXPR strong_ordering > operator<=>(const _Self& __x, const _Self& __y) noexcept > { > if (const auto __cmp = __x._M_node <=> __y._M_node; __cmp != 0) > @@ -297,20 +302,20 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > } > #else > _GLIBCXX_NODISCARD > - friend bool > + friend _GLIBCXX26_CONSTEXPR bool > operator!=(const _Self& __x, const _Self& __y) _GLIBCXX_NOEXCEPT > { return !(__x == __y); } > > template<typename _RefR, typename _PtrR> > _GLIBCXX_NODISCARD > - friend bool > + friend _GLIBCXX26_CONSTEXPR bool > operator!=(const _Self& __x, > const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) > _GLIBCXX_NOEXCEPT > { return !(__x == __y); } > > _GLIBCXX_NODISCARD > - friend bool > + friend _GLIBCXX26_CONSTEXPR bool > operator<(const _Self& __x, const _Self& __y) _GLIBCXX_NOEXCEPT > { > return (__x._M_node == __y._M_node) > @@ -319,7 +324,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > > template<typename _RefR, typename _PtrR> > _GLIBCXX_NODISCARD > - friend bool > + friend _GLIBCXX26_CONSTEXPR bool > operator<(const _Self& __x, > const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) > _GLIBCXX_NOEXCEPT > @@ -329,39 +334,39 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > } > > _GLIBCXX_NODISCARD > - friend bool > + friend _GLIBCXX26_CONSTEXPR bool > operator>(const _Self& __x, const _Self& __y) _GLIBCXX_NOEXCEPT > { return __y < __x; } > > template<typename _RefR, typename _PtrR> > _GLIBCXX_NODISCARD > - friend bool > + friend _GLIBCXX26_CONSTEXPR bool > operator>(const _Self& __x, > const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) > _GLIBCXX_NOEXCEPT > { return __y < __x; } > > _GLIBCXX_NODISCARD > - friend bool > + friend _GLIBCXX26_CONSTEXPR bool > operator<=(const _Self& __x, const _Self& __y) _GLIBCXX_NOEXCEPT > { return !(__y < __x); } > > template<typename _RefR, typename _PtrR> > _GLIBCXX_NODISCARD > - friend bool > + friend _GLIBCXX26_CONSTEXPR bool > operator<=(const _Self& __x, > const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) > _GLIBCXX_NOEXCEPT > { return !(__y < __x); } > > _GLIBCXX_NODISCARD > - friend bool > + friend _GLIBCXX26_CONSTEXPR bool > operator>=(const _Self& __x, const _Self& __y) _GLIBCXX_NOEXCEPT > { return !(__x < __y); } > > template<typename _RefR, typename _PtrR> > _GLIBCXX_NODISCARD > - friend bool > + friend _GLIBCXX26_CONSTEXPR bool > operator>=(const _Self& __x, > const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) > _GLIBCXX_NOEXCEPT > @@ -369,7 +374,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > #endif // three-way comparison > > _GLIBCXX_NODISCARD > - friend difference_type > + friend _GLIBCXX26_CONSTEXPR difference_type > operator-(const _Self& __x, const _Self& __y) _GLIBCXX_NOEXCEPT > { > return difference_type(_S_buffer_size()) > @@ -384,7 +389,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > // parameters. > template<typename _RefR, typename _PtrR> > _GLIBCXX_NODISCARD > - friend difference_type > + friend _GLIBCXX26_CONSTEXPR difference_type > operator-(const _Self& __x, > const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) > _GLIBCXX_NOEXCEPT > @@ -396,7 +401,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > } > > _GLIBCXX_NODISCARD > - friend _Self > + friend _GLIBCXX26_CONSTEXPR _Self > operator+(const _Self& __x, difference_type __n) _GLIBCXX_NOEXCEPT > { > _Self __tmp = __x; > @@ -405,7 +410,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > } > > _GLIBCXX_NODISCARD > - friend _Self > + friend _GLIBCXX26_CONSTEXPR _Self > operator-(const _Self& __x, difference_type __n) _GLIBCXX_NOEXCEPT > { > _Self __tmp = __x; > @@ -414,7 +419,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > } > > _GLIBCXX_NODISCARD > - friend _Self > + friend _GLIBCXX26_CONSTEXPR _Self > operator+(difference_type __n, const _Self& __x) _GLIBCXX_NOEXCEPT > { return __x + __n; } > > @@ -488,30 +493,35 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > > typedef _Alloc allocator_type; > > - allocator_type > + _GLIBCXX26_CONSTEXPR allocator_type > get_allocator() const _GLIBCXX_NOEXCEPT > { return allocator_type(_M_get_Tp_allocator()); } > > typedef _Deque_iterator<_Tp, _Tp&, _Ptr> iterator; > typedef _Deque_iterator<_Tp, const _Tp&, _Ptr_const> > const_iterator; > > + _GLIBCXX26_CONSTEXPR > _Deque_base() > : _M_impl() > { _M_initialize_map(0); } > > + _GLIBCXX26_CONSTEXPR > _Deque_base(size_t __num_elements) > : _M_impl() > { _M_initialize_map(__num_elements); } > > + _GLIBCXX26_CONSTEXPR > _Deque_base(const allocator_type& __a, size_t __num_elements) > : _M_impl(__a) > { _M_initialize_map(__num_elements); } > > + _GLIBCXX26_CONSTEXPR > _Deque_base(const allocator_type& __a) > : _M_impl(__a) > { /* Caller must initialize map. */ } > > #if __cplusplus >= 201103L > + _GLIBCXX26_CONSTEXPR > _Deque_base(_Deque_base&& __x) > : _M_impl(std::move(__x._M_get_Tp_allocator())) > { > @@ -520,10 +530,12 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > this->_M_impl._M_swap_data(__x._M_impl); > } > > + _GLIBCXX26_CONSTEXPR > _Deque_base(_Deque_base&& __x, const allocator_type& __a) > : _M_impl(std::move(__x._M_impl), _Tp_alloc_type(__a)) > { __x._M_initialize_map(0); } > > + _GLIBCXX26_CONSTEXPR > _Deque_base(_Deque_base&& __x, const allocator_type& __a, size_t > __n) > : _M_impl(__a) > { > @@ -542,6 +554,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > } > #endif > > + _GLIBCXX26_CONSTEXPR > ~_Deque_base() _GLIBCXX_NOEXCEPT; > > typedef typename iterator::_Map_pointer _Map_pointer; > @@ -553,6 +566,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > iterator _M_start; > iterator _M_finish; > > + _GLIBCXX26_CONSTEXPR > _Deque_impl_data() _GLIBCXX_NOEXCEPT > : _M_map(), _M_map_size(), _M_start(), _M_finish() > { } > @@ -562,12 +576,13 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > _Deque_impl_data& > operator=(const _Deque_impl_data&) = default; > > + _GLIBCXX26_CONSTEXPR > _Deque_impl_data(_Deque_impl_data&& __x) noexcept > : _Deque_impl_data(__x) > { __x = _Deque_impl_data(); } > #endif > > - void > + _GLIBCXX26_CONSTEXPR void > _M_swap_data(_Deque_impl_data& __x) _GLIBCXX_NOEXCEPT > { > // Do not use std::swap(_M_start, __x._M_start), etc as it loses > @@ -582,11 +597,13 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > struct _Deque_impl > : public _Tp_alloc_type, public _Deque_impl_data > { > + _GLIBCXX26_CONSTEXPR > _Deque_impl() _GLIBCXX_NOEXCEPT_IF( > is_nothrow_default_constructible<_Tp_alloc_type>::value) > : _Tp_alloc_type() > { } > > + _GLIBCXX26_CONSTEXPR > _Deque_impl(const _Tp_alloc_type& __a) _GLIBCXX_NOEXCEPT > : _Tp_alloc_type(__a) > { } > @@ -594,66 +611,74 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > #if __cplusplus >= 201103L > _Deque_impl(_Deque_impl&&) = default; > > + _GLIBCXX26_CONSTEXPR > _Deque_impl(_Tp_alloc_type&& __a) noexcept > : _Tp_alloc_type(std::move(__a)) > { } > > + _GLIBCXX26_CONSTEXPR > _Deque_impl(_Deque_impl&& __d, _Tp_alloc_type&& __a) > : _Tp_alloc_type(std::move(__a)), _Deque_impl_data(std::move(__d)) > { } > #endif > }; > > - _Tp_alloc_type& > + _GLIBCXX26_CONSTEXPR _Tp_alloc_type& > _M_get_Tp_allocator() _GLIBCXX_NOEXCEPT > { return this->_M_impl; } > > - const _Tp_alloc_type& > + _GLIBCXX26_CONSTEXPR const _Tp_alloc_type& > _M_get_Tp_allocator() const _GLIBCXX_NOEXCEPT > { return this->_M_impl; } > > - _Map_alloc_type > + _GLIBCXX26_CONSTEXPR _Map_alloc_type > _M_get_map_allocator() const _GLIBCXX_NOEXCEPT > { return _Map_alloc_type(_M_get_Tp_allocator()); } > > - _Ptr > + _GLIBCXX26_CONSTEXPR _Ptr > _M_allocate_node() > { > typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Traits; > return _Traits::allocate(_M_impl, __deque_buf_size(sizeof(_Tp))); > } > > - void > + _GLIBCXX26_CONSTEXPR void > _M_deallocate_node(_Ptr __p) _GLIBCXX_NOEXCEPT > { > typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Traits; > _Traits::deallocate(_M_impl, __p, __deque_buf_size(sizeof(_Tp))); > } > > - _Map_pointer > + _GLIBCXX26_CONSTEXPR _Map_pointer > _M_allocate_map(size_t __n) > { > _Map_alloc_type __map_alloc = _M_get_map_allocator(); > return _Map_alloc_traits::allocate(__map_alloc, __n); > } > > - void > + _GLIBCXX26_CONSTEXPR void > _M_deallocate_map(_Map_pointer __p, size_t __n) _GLIBCXX_NOEXCEPT > { > _Map_alloc_type __map_alloc = _M_get_map_allocator(); > _Map_alloc_traits::deallocate(__map_alloc, __p, __n); > } > > - void _M_initialize_map(size_t); > - void _M_create_nodes(_Map_pointer __nstart, _Map_pointer __nfinish); > - void _M_destroy_nodes(_Map_pointer __nstart, > - _Map_pointer __nfinish) _GLIBCXX_NOEXCEPT; > + _GLIBCXX26_CONSTEXPR void > + _M_initialize_map(size_t); > + > + _GLIBCXX26_CONSTEXPR void > + _M_create_nodes(_Map_pointer __nstart, _Map_pointer __nfinish); > + > + _GLIBCXX26_CONSTEXPR void > + _M_destroy_nodes(_Map_pointer __nstart, _Map_pointer __nfinish) > _GLIBCXX_NOEXCEPT; > + > enum { _S_initial_map_size = 8 }; > > _Deque_impl _M_impl; > }; > > template<typename _Tp, typename _Alloc> > + _GLIBCXX26_CONSTEXPR > _Deque_base<_Tp, _Alloc>:: > ~_Deque_base() _GLIBCXX_NOEXCEPT > { > @@ -673,7 +698,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * The initial underlying memory layout is a bit complicated... > */ > template<typename _Tp, typename _Alloc> > - void > + _GLIBCXX26_CONSTEXPR void > _Deque_base<_Tp, _Alloc>:: > _M_initialize_map(size_t __num_elements) > { > @@ -712,7 +737,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > } > > template<typename _Tp, typename _Alloc> > - void > + _GLIBCXX26_CONSTEXPR void > _Deque_base<_Tp, _Alloc>:: > _M_create_nodes(_Map_pointer __nstart, _Map_pointer __nfinish) > { > @@ -730,7 +755,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > } > > template<typename _Tp, typename _Alloc> > - void > + _GLIBCXX26_CONSTEXPR void > _Deque_base<_Tp, _Alloc>:: > _M_destroy_nodes(_Map_pointer __nstart, > _Map_pointer __nfinish) _GLIBCXX_NOEXCEPT > @@ -864,7 +889,8 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > typedef _Alloc allocator_type; > > private: > - static size_t _S_buffer_size() _GLIBCXX_NOEXCEPT > + static _GLIBCXX26_CONSTEXPR size_t > + _S_buffer_size() _GLIBCXX_NOEXCEPT > { return __deque_buf_size(sizeof(_Tp)); } > > // Functions controlling memory layout, and nothing else. > @@ -900,7 +926,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * @brief Creates a %deque with no elements. > * @param __a An allocator object. > */ > - explicit > + explicit _GLIBCXX26_CONSTEXPR > deque(const allocator_type& __a) > : _Base(__a, 0) { } > > @@ -913,7 +939,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * This constructor fills the %deque with @a n default > * constructed elements. > */ > - explicit > + explicit _GLIBCXX26_CONSTEXPR > deque(size_type __n, const allocator_type& __a = allocator_type()) > : _Base(__a, _S_check_init_len(__n, __a)) > { _M_default_initialize(); } > @@ -926,6 +952,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * > * This constructor fills the %deque with @a __n copies of @a > __value. > */ > + _GLIBCXX26_CONSTEXPR > deque(size_type __n, const value_type& __value, > const allocator_type& __a = allocator_type()) > : _Base(__a, _S_check_init_len(__n, __a)) > @@ -953,6 +980,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * The newly-created %deque uses a copy of the allocator object > used > * by @a __x (unless the allocator traits dictate a different > object). > */ > + _GLIBCXX26_CONSTEXPR > deque(const deque& __x) > : _Base(_Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator()), > __x.size()) > @@ -972,6 +1000,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > deque(deque&&) = default; > > /// Copy constructor with alternative allocator > + _GLIBCXX26_CONSTEXPR > deque(const deque& __x, const __type_identity_t<allocator_type>& > __a) > : _Base(__a, __x.size()) > { std::__uninitialized_copy_a(__x.begin(), __x.end(), > @@ -979,15 +1008,18 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > _M_get_Tp_allocator()); } > > /// Move constructor with alternative allocator > + _GLIBCXX26_CONSTEXPR > deque(deque&& __x, const __type_identity_t<allocator_type>& __a) > : deque(std::move(__x), __a, typename > _Alloc_traits::is_always_equal{}) > { } > > private: > + _GLIBCXX26_CONSTEXPR > deque(deque&& __x, const allocator_type& __a, true_type) > : _Base(std::move(__x), __a) > { } > > + _GLIBCXX26_CONSTEXPR > deque(deque&& __x, const allocator_type& __a, false_type) > : _Base(std::move(__x), __a, __x.size()) > { > @@ -1012,6 +1044,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * This will call the element type's copy constructor N times > * (where N is __l.size()) and do no memory reallocation. > */ > + _GLIBCXX26_CONSTEXPR > deque(initializer_list<value_type> __l, > const allocator_type& __a = allocator_type()) > : _Base(__a) > @@ -1039,6 +1072,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > #if __cplusplus >= 201103L > template<typename _InputIterator, > typename = std::_RequireInputIter<_InputIterator>> > + _GLIBCXX26_CONSTEXPR > deque(_InputIterator __first, _InputIterator __last, > const allocator_type& __a = allocator_type()) > : _Base(__a) > @@ -1065,6 +1099,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * @since C++23 > */ > template<__detail::__container_compatible_range<_Tp> _Rg> > + _GLIBCXX26_CONSTEXPR > deque(from_range_t, _Rg&& __rg, const allocator_type& __a = > _Alloc()) > : deque(__a) > { append_range(std::forward<_Rg>(__rg)); } > @@ -1075,6 +1110,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * themselves are pointers, the pointed-to memory is not touched > in any > * way. Managing the pointer is the user's responsibility. > */ > + _GLIBCXX26_CONSTEXPR > ~deque() > { _M_destroy_data(begin(), end(), _M_get_Tp_allocator()); } > > @@ -1087,7 +1123,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * The newly-created %deque uses a copy of the allocator object > used > * by @a __x (unless the allocator traits dictate a different > object). > */ > - deque& > + _GLIBCXX26_CONSTEXPR deque& > operator=(const deque& __x); > > #if __cplusplus >= 201103L > @@ -1099,7 +1135,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * if the allocators permit it). > * @a __x is a valid, but unspecified %deque. > */ > - deque& > + _GLIBCXX26_CONSTEXPR deque& > operator=(deque&& __x) noexcept(_Alloc_traits::_S_always_equal()) > { > using __always_equal = typename _Alloc_traits::is_always_equal; > @@ -1118,7 +1154,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * resulting %deque's size is the same as the number of elements > * assigned. > */ > - deque& > + _GLIBCXX26_CONSTEXPR deque& > operator=(initializer_list<value_type> __l) > { > _M_assign_aux(__l.begin(), __l.end(), > @@ -1137,7 +1173,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * %deque and that the resulting %deque's size is the same as > * the number of elements assigned. > */ > - void > + _GLIBCXX26_CONSTEXPR void > assign(size_type __n, const value_type& __val) > { _M_fill_assign(__n, __val); } > > @@ -1156,7 +1192,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > #if __cplusplus >= 201103L > template<typename _InputIterator, > typename = std::_RequireInputIter<_InputIterator>> > - void > + _GLIBCXX26_CONSTEXPR void > assign(_InputIterator __first, _InputIterator __last) > { _M_assign_aux(__first, __last, > std::__iterator_category(__first)); } > #else > @@ -1181,7 +1217,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * resulting %deque's size is the same as the number of elements > * assigned. > */ > - void > + _GLIBCXX26_CONSTEXPR void > assign(initializer_list<value_type> __l) > { _M_assign_aux(__l.begin(), __l.end(), > random_access_iterator_tag()); } > #endif > @@ -1235,7 +1271,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > > /// Get a copy of the memory allocation object. > _GLIBCXX_NODISCARD > - allocator_type > + _GLIBCXX26_CONSTEXPR allocator_type > get_allocator() const _GLIBCXX_NOEXCEPT > { return _Base::get_allocator(); } > > @@ -1245,7 +1281,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * %deque. Iteration is done in ordinary element order. > */ > _GLIBCXX_NODISCARD > - iterator > + _GLIBCXX26_CONSTEXPR iterator > begin() _GLIBCXX_NOEXCEPT > { return this->_M_impl._M_start; } > > @@ -1254,7 +1290,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * element in the %deque. Iteration is done in ordinary element > order. > */ > _GLIBCXX_NODISCARD > - const_iterator > + _GLIBCXX26_CONSTEXPR const_iterator > begin() const _GLIBCXX_NOEXCEPT > { return this->_M_impl._M_start; } > > @@ -1264,7 +1300,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * element order. > */ > _GLIBCXX_NODISCARD > - iterator > + _GLIBCXX26_CONSTEXPR iterator > end() _GLIBCXX_NOEXCEPT > { return this->_M_impl._M_finish; } > > @@ -1274,7 +1310,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * ordinary element order. > */ > _GLIBCXX_NODISCARD > - const_iterator > + _GLIBCXX26_CONSTEXPR const_iterator > end() const _GLIBCXX_NOEXCEPT > { return this->_M_impl._M_finish; } > > @@ -1284,7 +1320,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * element order. > */ > _GLIBCXX_NODISCARD > - reverse_iterator > + _GLIBCXX26_CONSTEXPR reverse_iterator > rbegin() _GLIBCXX_NOEXCEPT > { return reverse_iterator(this->_M_impl._M_finish); } > > @@ -1294,7 +1330,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * reverse element order. > */ > _GLIBCXX_NODISCARD > - const_reverse_iterator > + _GLIBCXX26_CONSTEXPR const_reverse_iterator > rbegin() const _GLIBCXX_NOEXCEPT > { return const_reverse_iterator(this->_M_impl._M_finish); } > > @@ -1304,7 +1340,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * in reverse element order. > */ > _GLIBCXX_NODISCARD > - reverse_iterator > + _GLIBCXX26_CONSTEXPR reverse_iterator > rend() _GLIBCXX_NOEXCEPT > { return reverse_iterator(this->_M_impl._M_start); } > > @@ -1314,7 +1350,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * done in reverse element order. > */ > _GLIBCXX_NODISCARD > - const_reverse_iterator > + _GLIBCXX26_CONSTEXPR const_reverse_iterator > rend() const _GLIBCXX_NOEXCEPT > { return const_reverse_iterator(this->_M_impl._M_start); } > > @@ -1324,7 +1360,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * element in the %deque. Iteration is done in ordinary element > order. > */ > [[__nodiscard__]] > - const_iterator > + _GLIBCXX26_CONSTEXPR const_iterator > cbegin() const noexcept > { return this->_M_impl._M_start; } > > @@ -1334,7 +1370,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * ordinary element order. > */ > [[__nodiscard__]] > - const_iterator > + _GLIBCXX26_CONSTEXPR const_iterator > cend() const noexcept > { return this->_M_impl._M_finish; } > > @@ -1344,7 +1380,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * reverse element order. > */ > [[__nodiscard__]] > - const_reverse_iterator > + _GLIBCXX26_CONSTEXPR const_reverse_iterator > crbegin() const noexcept > { return const_reverse_iterator(this->_M_impl._M_finish); } > > @@ -1354,7 +1390,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * done in reverse element order. > */ > [[__nodiscard__]] > - const_reverse_iterator > + _GLIBCXX26_CONSTEXPR const_reverse_iterator > crend() const noexcept > { return const_reverse_iterator(this->_M_impl._M_start); } > #endif > @@ -1362,7 +1398,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > // [23.2.1.2] capacity > /** Returns the number of elements in the %deque. */ > _GLIBCXX_NODISCARD > - size_type > + _GLIBCXX26_CONSTEXPR size_type > size() const _GLIBCXX_NOEXCEPT > { > size_type __sz = this->_M_impl._M_finish - this->_M_impl._M_start; > @@ -1373,7 +1409,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > > /** Returns the size() of the largest possible %deque. */ > _GLIBCXX_NODISCARD > - size_type > + _GLIBCXX26_CONSTEXPR size_type > max_size() const _GLIBCXX_NOEXCEPT > { return _S_max_size(_M_get_Tp_allocator()); } > > @@ -1387,7 +1423,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * %deque's current size the %deque is truncated, otherwise > * default constructed elements are appended. > */ > - void > + _GLIBCXX26_CONSTEXPR void > resize(size_type __new_size) > { > const size_type __len = size(); > @@ -1409,7 +1445,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * %deque is extended and new elements are populated with given > * data. > */ > - void > + _GLIBCXX26_CONSTEXPR void > resize(size_type __new_size, const value_type& __x) > #else > /** > @@ -1437,7 +1473,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > > #if __cplusplus >= 201103L > /** A non-binding request to reduce memory use. */ > - void > + _GLIBCXX26_CONSTEXPR void > shrink_to_fit() noexcept > { _M_shrink_to_fit(); } > #endif > @@ -1446,7 +1482,8 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * Returns true if the %deque is empty. (Thus begin() would > * equal end().) > */ > - _GLIBCXX_NODISCARD bool > + _GLIBCXX_NODISCARD > + _GLIBCXX26_CONSTEXPR bool > empty() const _GLIBCXX_NOEXCEPT > { return this->_M_impl._M_finish == this->_M_impl._M_start; } > > @@ -1463,7 +1500,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * see at().) > */ > _GLIBCXX_NODISCARD > - reference > + _GLIBCXX26_CONSTEXPR reference > operator[](size_type __n) _GLIBCXX_NOEXCEPT > { > __glibcxx_requires_subscript(__n); > @@ -1482,7 +1519,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * see at().) > */ > _GLIBCXX_NODISCARD > - const_reference > + _GLIBCXX26_CONSTEXPR const_reference > operator[](size_type __n) const _GLIBCXX_NOEXCEPT > { > __glibcxx_requires_subscript(__n); > @@ -1491,7 +1528,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > > protected: > /// Safety check used only from at(). > - void > + _GLIBCXX26_CONSTEXPR void > _M_range_check(size_type __n) const > { > if (__n >= this->size()) > @@ -1513,7 +1550,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * is first checked that it is in the range of the deque. The > * function throws out_of_range if the check fails. > */ > - reference > + _GLIBCXX26_CONSTEXPR reference > at(size_type __n) > { > _M_range_check(__n); > @@ -1531,7 +1568,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * checked that it is in the range of the deque. The function > throws > * out_of_range if the check fails. > */ > - const_reference > + _GLIBCXX26_CONSTEXPR const_reference > at(size_type __n) const > { > _M_range_check(__n); > @@ -1543,7 +1580,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * element of the %deque. > */ > _GLIBCXX_NODISCARD > - reference > + _GLIBCXX26_CONSTEXPR reference > front() _GLIBCXX_NOEXCEPT > { > __glibcxx_requires_nonempty(); > @@ -1555,7 +1592,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * element of the %deque. > */ > _GLIBCXX_NODISCARD > - const_reference > + _GLIBCXX26_CONSTEXPR const_reference > front() const _GLIBCXX_NOEXCEPT > { > __glibcxx_requires_nonempty(); > @@ -1567,7 +1604,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * %deque. > */ > _GLIBCXX_NODISCARD > - reference > + _GLIBCXX26_CONSTEXPR reference > back() _GLIBCXX_NOEXCEPT > { > __glibcxx_requires_nonempty(); > @@ -1581,7 +1618,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * element of the %deque. > */ > _GLIBCXX_NODISCARD > - const_reference > + _GLIBCXX26_CONSTEXPR const_reference > back() const _GLIBCXX_NOEXCEPT > { > __glibcxx_requires_nonempty(); > @@ -1600,7 +1637,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * data to it. Due to the nature of a %deque this operation > * can be done in constant time. > */ > - void > + _GLIBCXX26_CONSTEXPR void > push_front(const value_type& __x) > { > if (this->_M_impl._M_start._M_cur != > this->_M_impl._M_start._M_first) > @@ -1615,13 +1652,13 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > } > > #if __cplusplus >= 201103L > - void > + _GLIBCXX26_CONSTEXPR void > push_front(value_type&& __x) > { emplace_front(std::move(__x)); } > > template<typename... _Args> > #if __cplusplus > 201402L > - reference > + _GLIBCXX26_CONSTEXPR reference > #else > void > #endif > @@ -1637,7 +1674,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * to it. Due to the nature of a %deque this operation can be > * done in constant time. > */ > - void > + _GLIBCXX26_CONSTEXPR void > push_back(const value_type& __x) > { > if (this->_M_impl._M_finish._M_cur > @@ -1652,13 +1689,13 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > } > > #if __cplusplus >= 201103L > - void > + _GLIBCXX26_CONSTEXPR void > push_back(value_type&& __x) > { emplace_back(std::move(__x)); } > > template<typename... _Args> > #if __cplusplus > 201402L > - reference > + _GLIBCXX26_CONSTEXPR reference > #else > void > #endif > @@ -1673,7 +1710,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * Note that no data is returned, and if the first element's data > is > * needed, it should be retrieved before pop_front() is called. > */ > - void > + _GLIBCXX26_CONSTEXPR void > pop_front() _GLIBCXX_NOEXCEPT > { > __glibcxx_requires_nonempty(); > @@ -1696,7 +1733,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * Note that no data is returned, and if the last element's data is > * needed, it should be retrieved before pop_back() is called. > */ > - void > + _GLIBCXX26_CONSTEXPR void > pop_back() _GLIBCXX_NOEXCEPT > { > __glibcxx_requires_nonempty(); > @@ -1722,7 +1759,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * with T(std::forward<Args>(args)...) before the specified > location. > */ > template<typename... _Args> > - iterator > + _GLIBCXX26_CONSTEXPR iterator > emplace(const_iterator __position, _Args&&... __args); > > /** > @@ -1734,7 +1771,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * This function will insert a copy of the given value before the > * specified location. > */ > - iterator > + _GLIBCXX26_CONSTEXPR iterator > insert(const_iterator __position, const value_type& __x); > #else > /** > @@ -1746,7 +1783,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * This function will insert a copy of the given value before the > * specified location. > */ > - iterator > + _GLIBCXX26_CONSTEXPR iterator > insert(iterator __position, const value_type& __x); > #endif > > @@ -1760,7 +1797,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * This function will insert a copy of the given rvalue before the > * specified location. > */ > - iterator > + _GLIBCXX26_CONSTEXPR iterator > insert(const_iterator __position, value_type&& __x) > { return emplace(__position, std::move(__x)); } > > @@ -1774,7 +1811,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * initializer_list @a __l into the %deque before the location > * specified by @a __p. This is known as <em>list insert</em>. > */ > - iterator > + _GLIBCXX26_CONSTEXPR iterator > insert(const_iterator __p, initializer_list<value_type> __l) > { > auto __offset = __p - cbegin(); > @@ -1793,7 +1830,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * This function will insert a specified number of copies of the > given > * data before the location specified by @a __position. > */ > - iterator > + _GLIBCXX26_CONSTEXPR iterator > insert(const_iterator __position, size_type __n, const value_type& > __x) > { > difference_type __offset = __position - cbegin(); > @@ -1810,7 +1847,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * This function will insert a specified number of copies of the > given > * data before the location specified by @a __position. > */ > - void > + _GLIBCXX26_CONSTEXPR void > insert(iterator __position, size_type __n, const value_type& __x) > { _M_fill_insert(__position, __n, __x); } > #endif > @@ -1829,7 +1866,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > */ > template<typename _InputIterator, > typename = std::_RequireInputIter<_InputIterator>> > - iterator > + _GLIBCXX26_CONSTEXPR iterator > insert(const_iterator __position, _InputIterator __first, > _InputIterator __last) > { > @@ -1850,7 +1887,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * by @a __position. This is known as <em>range insert</em>. > */ > template<typename _InputIterator> > - void > + _GLIBCXX26_CONSTEXPR void > insert(iterator __position, _InputIterator __first, > _InputIterator __last) > { > @@ -1870,7 +1907,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * @since C++23 > */ > template<__detail::__container_compatible_range<_Tp> _Rg> > - iterator > + _GLIBCXX26_CONSTEXPR iterator > insert_range(const_iterator __pos, _Rg&& __rg); > > /** > @@ -1879,7 +1916,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * @since C++23 > */ > template<__detail::__container_compatible_range<_Tp> _Rg> > - void > + _GLIBCXX26_CONSTEXPR void > prepend_range(_Rg&& __rg); > > /** > @@ -1888,7 +1925,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * @since C++23 > */ > template<__detail::__container_compatible_range<_Tp> _Rg> > - void > + _GLIBCXX26_CONSTEXPR void > append_range(_Rg&& __rg); > #endif // containers_ranges > > @@ -1905,7 +1942,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * itself a pointer, the pointed-to memory is not touched in any > way. > * Managing the pointer is the user's responsibility. > */ > - iterator > + _GLIBCXX26_CONSTEXPR iterator > #if __cplusplus >= 201103L > erase(const_iterator __position) > #else > @@ -1929,7 +1966,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * themselves are pointers, the pointed-to memory is not touched > in any > * way. Managing the pointer is the user's responsibility. > */ > - iterator > + _GLIBCXX26_CONSTEXPR iterator > #if __cplusplus >= 201103L > erase(const_iterator __first, const_iterator __last) > #else > @@ -1948,7 +1985,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * > * Whether the allocators are swapped depends on the allocator > traits. > */ > - void > + _GLIBCXX26_CONSTEXPR void > swap(deque& __x) _GLIBCXX_NOEXCEPT > { > #if __cplusplus >= 201103L > @@ -1966,7 +2003,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * pointed-to memory is not touched in any way. Managing the > pointer is > * the user's responsibility. > */ > - void > + _GLIBCXX26_CONSTEXPR void > clear() _GLIBCXX_NOEXCEPT > { _M_erase_at_end(begin()); } > > @@ -1998,7 +2035,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > } > #endif > > - static size_t > + static _GLIBCXX26_CONSTEXPR size_t > _S_check_init_len(size_t __n, const allocator_type& __a) > { > if (__n > _S_max_size(__a)) > @@ -2007,7 +2044,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > return __n; > } > > - static size_type > + static _GLIBCXX26_CONSTEXPR size_type > _S_max_size(const _Tp_alloc_type& __a) _GLIBCXX_NOEXCEPT > { > const size_t __diffmax = > __gnu_cxx::__numeric_traits<ptrdiff_t>::__max; > @@ -2027,13 +2064,13 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * push_back on each value from the iterator. > */ > template<typename _InputIterator> > - void > + _GLIBCXX26_CONSTEXPR void > _M_range_initialize(_InputIterator __first, _InputIterator __last, > std::input_iterator_tag); > > // called by the second initialize_dispatch above > template<typename _ForwardIterator> > - void > + _GLIBCXX26_CONSTEXPR void > _M_range_initialize(_ForwardIterator __first, _ForwardIterator > __last, > std::forward_iterator_tag); > ///@} > @@ -2047,12 +2084,12 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * This function is called only when the user provides an explicit > size > * (with or without an explicit exemplar value). > */ > - void > + _GLIBCXX26_CONSTEXPR void > _M_fill_initialize(const value_type& __value); > > #if __cplusplus >= 201103L > // called by deque(n). > - void > + _GLIBCXX26_CONSTEXPR void > _M_default_initialize(); > #endif > > @@ -2079,13 +2116,13 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > > // called by the second assign_dispatch above > template<typename _InputIterator> > - void > + _GLIBCXX26_CONSTEXPR void > _M_assign_aux(_InputIterator __first, _InputIterator __last, > std::input_iterator_tag); > > // called by the second assign_dispatch above > template<typename _ForwardIterator> > - void > + _GLIBCXX26_CONSTEXPR void > _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, > std::forward_iterator_tag) > { > @@ -2104,7 +2141,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > > // Called by assign(n,t), and the range assign when it turns out > // to be the same thing. > - void > + _GLIBCXX26_CONSTEXPR void > _M_fill_assign(size_type __n, const value_type& __val) > { > if (__n > size()) > @@ -2127,15 +2164,19 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > void _M_push_front_aux(const value_type&); > #else > template<typename... _Args> > - void _M_push_back_aux(_Args&&... __args); > + _GLIBCXX26_CONSTEXPR void > + _M_push_back_aux(_Args&&... __args); > > template<typename... _Args> > - void _M_push_front_aux(_Args&&... __args); > + _GLIBCXX26_CONSTEXPR void > + _M_push_front_aux(_Args&&... __args); > #endif > > - void _M_pop_back_aux(); > + _GLIBCXX26_CONSTEXPR void > + _M_pop_back_aux(); > > - void _M_pop_front_aux(); > + _GLIBCXX26_CONSTEXPR void > + _M_pop_front_aux(); > ///@} > > // Internal insert functions follow. The *_aux functions do the > actual > @@ -2147,14 +2188,14 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > // _GLIBCXX_RESOLVE_LIB_DEFECTS > // 438. Ambiguity in the "do the right thing" clause > template<typename _Integer> > - void > + _GLIBCXX26_CONSTEXPR void > _M_insert_dispatch(iterator __pos, > _Integer __n, _Integer __x, __true_type) > { _M_fill_insert(__pos, __n, __x); } > > // called by the range insert to implement [23.1.1]/9 > template<typename _InputIterator> > - void > + _GLIBCXX26_CONSTEXPR void > _M_insert_dispatch(iterator __pos, > _InputIterator __first, _InputIterator __last, > __false_type) > @@ -2166,30 +2207,32 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > > // insert [__first, __last) at the front, assumes distance(__first, > __last) is n > template<typename _InputIterator, typename _Sentinel> > - void _M_range_prepend(_InputIterator __first, _Sentinel __last, > - size_type __n); > + _GLIBCXX26_CONSTEXPR void > + _M_range_prepend(_InputIterator __first, _Sentinel __last, > + size_type __n); > > // insert [__first, __last) at the back, assumes distance(__first, > __last) is n > template<typename _InputIterator, typename _Sentinel> > - void _M_range_append(_InputIterator __first, _Sentinel __last, > - size_type __n); > + _GLIBCXX26_CONSTEXPR void > + _M_range_append(_InputIterator __first, _Sentinel __last, > + size_type __n); > > // called by the second insert_dispatch above > template<typename _InputIterator> > - void > + _GLIBCXX26_CONSTEXPR void > _M_range_insert_aux(iterator __pos, _InputIterator __first, > _InputIterator __last, > std::input_iterator_tag); > > // called by the second insert_dispatch above > template<typename _ForwardIterator> > - void > + _GLIBCXX26_CONSTEXPR void > _M_range_insert_aux(iterator __pos, _ForwardIterator __first, > _ForwardIterator __last, > std::forward_iterator_tag); > > // Called by insert(p,n,x), and the range insert when it turns out > to be > // the same thing. Can use fill functions in optimal situations, > // otherwise passes off to insert_aux(p,n,x). > - void > + _GLIBCXX26_CONSTEXPR void > _M_fill_insert(iterator __pos, size_type __n, const value_type& > __x); > > // called by insert(p,x) > @@ -2200,22 +2243,22 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > struct _Temporary_value > { > template<typename... _Args> > - _GLIBCXX20_CONSTEXPR explicit > + explicit _GLIBCXX26_CONSTEXPR > _Temporary_value(deque* __deque, _Args&&... __args) : > _M_this(__deque) > { > _Alloc_traits::construct(_M_this->_M_impl, _M_ptr(), > std::forward<_Args>(__args)...); > } > > - _GLIBCXX20_CONSTEXPR > + _GLIBCXX26_CONSTEXPR > ~_Temporary_value() > { _Alloc_traits::destroy(_M_this->_M_impl, _M_ptr()); } > > - _GLIBCXX20_CONSTEXPR value_type& > + _GLIBCXX26_CONSTEXPR value_type& > _M_val() noexcept { return __tmp_val; } > > private: > - _GLIBCXX20_CONSTEXPR _Tp* > + _GLIBCXX26_CONSTEXPR _Tp* > _M_ptr() noexcept { return std::__addressof(__tmp_val); } > > union > @@ -2226,22 +2269,22 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > deque* _M_this; > }; > > - iterator > + _GLIBCXX26_CONSTEXPR iterator > _M_insert_aux(iterator __pos, const value_type& __x) > { return _M_emplace_aux(__pos, __x); } > > template<typename... _Args> > - iterator > + _GLIBCXX26_CONSTEXPR iterator > _M_emplace_aux(iterator __pos, _Args&&... __args); > #endif > > // called by insert(p,n,x) via fill_insert > - void > + _GLIBCXX26_CONSTEXPR void > _M_insert_aux(iterator __pos, size_type __n, const value_type& __x); > > // called by range_insert_aux for forward iterators > template<typename _ForwardIterator> > - void > + _GLIBCXX26_CONSTEXPR void > _M_insert_aux(iterator __pos, > _ForwardIterator __first, _ForwardIterator __last, > size_type __n); > @@ -2249,17 +2292,17 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > > // Internal erase functions follow. > > - void > + _GLIBCXX26_CONSTEXPR void > _M_destroy_data_aux(iterator __first, iterator __last); > > // Called by ~deque(). > // NB: Doesn't deallocate the nodes. > template<typename _Alloc1> > - void > + _GLIBCXX26_CONSTEXPR void > _M_destroy_data(iterator __first, iterator __last, const _Alloc1&) > { _M_destroy_data_aux(__first, __last); } > > - void > + _GLIBCXX26_CONSTEXPR void > _M_destroy_data(iterator __first, iterator __last, > const std::allocator<_Tp>&) > { > @@ -2268,7 +2311,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > } > > // Called by erase(q1, q2). > - void > + _GLIBCXX26_CONSTEXPR void > _M_erase_at_begin(iterator __pos) > { > _M_destroy_data(begin(), __pos, _M_get_Tp_allocator()); > @@ -2278,7 +2321,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > > // Called by erase(q1, q2), resize(), clear(), _M_assign_aux, > // _M_fill_assign, operator=. > - void > + _GLIBCXX26_CONSTEXPR void > _M_erase_at_end(iterator __pos) > { > _M_destroy_data(__pos, end(), _M_get_Tp_allocator()); > @@ -2287,24 +2330,24 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > this->_M_impl._M_finish = __pos; > } > > - iterator > + _GLIBCXX26_CONSTEXPR iterator > _M_erase(iterator __pos); > > - iterator > + _GLIBCXX26_CONSTEXPR iterator > _M_erase(iterator __first, iterator __last); > > #if __cplusplus >= 201103L > // Called by resize(sz). > - void > + _GLIBCXX26_CONSTEXPR void > _M_default_append(size_type __n); > > - bool > + _GLIBCXX26_CONSTEXPR bool > _M_shrink_to_fit(); > #endif > > ///@{ > /// Memory-handling helpers for the previous internal insert > functions. > - iterator > + _GLIBCXX26_CONSTEXPR iterator > _M_reserve_elements_at_front(size_type __n) > { > const size_type __vacancies = this->_M_impl._M_start._M_cur > @@ -2314,7 +2357,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > return this->_M_impl._M_start - difference_type(__n); > } > > - iterator > + _GLIBCXX26_CONSTEXPR iterator > _M_reserve_elements_at_back(size_type __n) > { > const size_type __vacancies = (this->_M_impl._M_finish._M_last > @@ -2324,10 +2367,10 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > return this->_M_impl._M_finish + difference_type(__n); > } > > - void > + _GLIBCXX26_CONSTEXPR void > _M_new_elements_at_front(size_type __new_elements); > > - void > + _GLIBCXX26_CONSTEXPR void > _M_new_elements_at_back(size_type __new_elements); > ///@} > > @@ -2340,7 +2383,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > * actually add the nodes. Can invalidate _M_map pointers. > * (And consequently, %deque iterators.) > */ > - void > + _GLIBCXX26_CONSTEXPR void > _M_reserve_map_at_back(size_type __nodes_to_add = 1) > { > if (__nodes_to_add + 1 > this->_M_impl._M_map_size > @@ -2348,7 +2391,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > _M_reallocate_map(__nodes_to_add, false); > } > > - void > + _GLIBCXX26_CONSTEXPR void > _M_reserve_map_at_front(size_type __nodes_to_add = 1) > { > if (__nodes_to_add > size_type(this->_M_impl._M_start._M_node > @@ -2356,14 +2399,14 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > _M_reallocate_map(__nodes_to_add, true); > } > > - void > + _GLIBCXX26_CONSTEXPR void > _M_reallocate_map(size_type __nodes_to_add, bool __add_at_front); > ///@} > > #if __cplusplus >= 201103L > // Constant-time, nothrow move assignment when source object's > memory > // can be moved because the allocators are equal. > - void > + _GLIBCXX26_CONSTEXPR void > _M_move_assign1(deque&& __x, /* always equal: */ true_type) noexcept > { > this->_M_impl._M_swap_data(__x._M_impl); > @@ -2374,7 +2417,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > // When the allocators are not equal the operation could throw, > because > // we might need to allocate a new map for __x after moving from it > // or we might need to allocate new elements for *this. > - void > + _GLIBCXX26_CONSTEXPR void > _M_move_assign1(deque&& __x, /* always equal: */ false_type) > { > if (_M_get_Tp_allocator() == __x._M_get_Tp_allocator()) > @@ -2388,7 +2431,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > // Destroy all elements and deallocate all memory, then replace > // with elements created from __args. > template<typename... _Args> > - void > + _GLIBCXX26_CONSTEXPR void > _M_replace_map(_Args&&... __args) > { > // Create new data first, so if allocation fails there are no > effects. > @@ -2404,7 +2447,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > } > > // Do move assignment when the allocator propagates. > - void > + _GLIBCXX26_CONSTEXPR void > _M_move_assign2(deque&& __x, /* propagate: */ true_type) > { > // Make a copy of the original allocator state. > @@ -2418,7 +2461,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > > // Do move assignment when it may not be possible to move source > // object's memory, resulting in a linear-time operation. > - void > + _GLIBCXX26_CONSTEXPR void > _M_move_assign2(deque&& __x, /* propagate: */ false_type) > { > if (__x._M_get_Tp_allocator() == this->_M_get_Tp_allocator()) > @@ -2469,7 +2512,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > */ > template<typename _Tp, typename _Alloc> > _GLIBCXX_NODISCARD > - inline bool > + inline _GLIBCXX26_CONSTEXPR bool > operator==(const deque<_Tp, _Alloc>& __x, const deque<_Tp, _Alloc>& > __y) > { return __x.size() == __y.size() > && std::equal(__x.begin(), __x.end(), __y.begin()); } > @@ -2488,7 +2531,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > */ > template<typename _Tp, typename _Alloc> > [[nodiscard]] > - inline __detail::__synth3way_t<_Tp> > + inline _GLIBCXX26_CONSTEXPR __detail::__synth3way_t<_Tp> > operator<=>(const deque<_Tp, _Alloc>& __x, const deque<_Tp, _Alloc>& > __y) > { > return std::lexicographical_compare_three_way(__x.begin(), > __x.end(), > @@ -2545,7 +2588,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER > > /// See std::deque::swap(). > template<typename _Tp, typename _Alloc> > - inline void > + inline _GLIBCXX26_CONSTEXPR void > swap(deque<_Tp,_Alloc>& __x, deque<_Tp,_Alloc>& __y) > _GLIBCXX_NOEXCEPT_IF(noexcept(__x.swap(__y))) > { __x.swap(__y); } > diff --git a/libstdc++-v3/include/bits/stl_queue.h > b/libstdc++-v3/include/bits/stl_queue.h > index d9edc4c838d..ced5660bc97 100644 > --- a/libstdc++-v3/include/bits/stl_queue.h > +++ b/libstdc++-v3/include/bits/stl_queue.h > @@ -115,16 +115,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > #endif > > template<typename _Tp1, typename _Seq1> > - friend bool > + friend _GLIBCXX26_CONSTEXPR bool > operator==(const queue<_Tp1, _Seq1>&, const queue<_Tp1, _Seq1>&); > > template<typename _Tp1, typename _Seq1> > - friend bool > + friend _GLIBCXX26_CONSTEXPR bool > operator<(const queue<_Tp1, _Seq1>&, const queue<_Tp1, _Seq1>&); > > #if __cpp_lib_three_way_comparison > template<typename _Tp1, three_way_comparable _Seq1> > - friend compare_three_way_result_t<_Seq1> > + friend _GLIBCXX26_CONSTEXPR compare_three_way_result_t<_Seq1> > operator<=>(const queue<_Tp1, _Seq1>&, const queue<_Tp1, _Seq1>&); > #endif > > @@ -171,35 +171,40 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > #else > template<typename _Seq = _Sequence, typename _Requires = typename > enable_if<is_default_constructible<_Seq>::value>::type> > + _GLIBCXX26_CONSTEXPR > queue() > : c() { } > > - explicit > + explicit _GLIBCXX26_CONSTEXPR > queue(const _Sequence& __c) > : c(__c) { } > > - explicit > + explicit _GLIBCXX26_CONSTEXPR > queue(_Sequence&& __c) > : c(std::move(__c)) { } > > template<typename _Alloc, typename _Requires = _Uses<_Alloc>> > - explicit > + explicit _GLIBCXX26_CONSTEXPR > queue(const _Alloc& __a) > : c(__a) { } > > template<typename _Alloc, typename _Requires = _Uses<_Alloc>> > + _GLIBCXX26_CONSTEXPR > queue(const _Sequence& __c, const _Alloc& __a) > : c(__c, __a) { } > > template<typename _Alloc, typename _Requires = _Uses<_Alloc>> > + _GLIBCXX26_CONSTEXPR > queue(_Sequence&& __c, const _Alloc& __a) > : c(std::move(__c), __a) { } > > template<typename _Alloc, typename _Requires = _Uses<_Alloc>> > + _GLIBCXX26_CONSTEXPR > queue(const queue& __q, const _Alloc& __a) > : c(__q.c, __a) { } > > template<typename _Alloc, typename _Requires = _Uses<_Alloc>> > + _GLIBCXX26_CONSTEXPR > queue(queue&& __q, const _Alloc& __a) > : c(std::move(__q.c), __a) { } > #endif > @@ -207,12 +212,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > #ifdef __glibcxx_adaptor_iterator_pair_constructor // C++ >= 23 && HOSTED > template<typename _InputIterator, > typename = _RequireInputIter<_InputIterator>> > + _GLIBCXX26_CONSTEXPR > queue(_InputIterator __first, _InputIterator __last) > : c(__first, __last) { } > > template<typename _InputIterator, typename _Alloc, > typename = _RequireInputIter<_InputIterator>, > typename = _Uses<_Alloc>> > + _GLIBCXX26_CONSTEXPR > queue(_InputIterator __first, _InputIterator __last, const _Alloc& > __a) > : c(__first, __last, __a) { } > #endif > @@ -223,6 +230,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > * @since C++23 > */ > template<__detail::__container_compatible_range<_Tp> _Rg> > + _GLIBCXX26_CONSTEXPR > queue(from_range_t, _Rg&& __rg) > : c(ranges::to<_Sequence>(std::forward<_Rg>(__rg))) > { } > @@ -233,6 +241,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > */ > template<__detail::__container_compatible_range<_Tp> _Rg, > typename _Alloc> > + _GLIBCXX26_CONSTEXPR > queue(from_range_t, _Rg&& __rg, const _Alloc& __a) > : c(ranges::to<_Sequence>(std::forward<_Rg>(__rg), __a)) > { } > @@ -241,13 +250,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > /** > * Returns true if the %queue is empty. > */ > - _GLIBCXX_NODISCARD bool > + _GLIBCXX_NODISCARD > + _GLIBCXX26_CONSTEXPR bool > empty() const > { return c.empty(); } > > /** Returns the number of elements in the %queue. */ > _GLIBCXX_NODISCARD > - size_type > + _GLIBCXX26_CONSTEXPR size_type > size() const > { return c.size(); } > > @@ -256,7 +266,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > * element of the %queue. > */ > _GLIBCXX_NODISCARD > - reference > + _GLIBCXX26_CONSTEXPR reference > front() > { > __glibcxx_requires_nonempty(); > @@ -268,7 +278,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > * element of the %queue. > */ > _GLIBCXX_NODISCARD > - const_reference > + _GLIBCXX26_CONSTEXPR const_reference > front() const > { > __glibcxx_requires_nonempty(); > @@ -280,7 +290,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > * element of the %queue. > */ > _GLIBCXX_NODISCARD > - reference > + _GLIBCXX26_CONSTEXPR reference > back() > { > __glibcxx_requires_nonempty(); > @@ -292,7 +302,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > * element of the %queue. > */ > _GLIBCXX_NODISCARD > - const_reference > + _GLIBCXX26_CONSTEXPR const_reference > back() const > { > __glibcxx_requires_nonempty(); > @@ -308,18 +318,18 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > * to it. The time complexity of the operation depends on the > * underlying sequence. > */ > - void > + _GLIBCXX26_CONSTEXPR void > push(const value_type& __x) > { c.push_back(__x); } > > #if __cplusplus >= 201103L > - void > + _GLIBCXX26_CONSTEXPR void > push(value_type&& __x) > { c.push_back(std::move(__x)); } > > #if __cplusplus > 201402L > template<typename... _Args> > - decltype(auto) > + _GLIBCXX26_CONSTEXPR decltype(auto) > emplace(_Args&&... __args) > { return c.emplace_back(std::forward<_Args>(__args)...); } > #else > @@ -332,7 +342,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > > #if __glibcxx_containers_ranges // C++ >= 23 > template<__detail::__container_compatible_range<_Tp> _Rg> > - void > + _GLIBCXX26_CONSTEXPR void > push_range(_Rg&& __rg) > { > if constexpr (requires { > c.append_range(std::forward<_Rg>(__rg)); }) > @@ -353,7 +363,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > * data is needed, it should be retrieved before pop() is > * called. > */ > - void > + _GLIBCXX26_CONSTEXPR void > pop() > { > __glibcxx_requires_nonempty(); > @@ -361,7 +371,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > } > > #if __cplusplus >= 201103L > - void > + _GLIBCXX26_CONSTEXPR void > swap(queue& __q) > #if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11 > noexcept(__is_nothrow_swappable<_Sequence>::value) > @@ -430,7 +440,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > */ > template<typename _Tp, typename _Seq> > _GLIBCXX_NODISCARD > - inline bool > + inline _GLIBCXX26_CONSTEXPR bool > operator==(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y) > { return __x.c == __y.c; } > > @@ -449,49 +459,49 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > */ > template<typename _Tp, typename _Seq> > _GLIBCXX_NODISCARD > - inline bool > + inline _GLIBCXX26_CONSTEXPR bool > operator<(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y) > { return __x.c < __y.c; } > > /// Based on operator== > template<typename _Tp, typename _Seq> > _GLIBCXX_NODISCARD > - inline bool > + inline _GLIBCXX26_CONSTEXPR bool > operator!=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y) > { return !(__x == __y); } > > /// Based on operator< > template<typename _Tp, typename _Seq> > _GLIBCXX_NODISCARD > - inline bool > + inline _GLIBCXX26_CONSTEXPR bool > operator>(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y) > { return __y < __x; } > > /// Based on operator< > template<typename _Tp, typename _Seq> > _GLIBCXX_NODISCARD > - inline bool > + inline _GLIBCXX26_CONSTEXPR bool > operator<=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y) > { return !(__y < __x); } > > /// Based on operator< > template<typename _Tp, typename _Seq> > _GLIBCXX_NODISCARD > - inline bool > + inline _GLIBCXX26_CONSTEXPR bool > operator>=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y) > { return !(__x < __y); } > > #if __cpp_lib_three_way_comparison > template<typename _Tp, three_way_comparable _Seq> > [[nodiscard]] > - inline compare_three_way_result_t<_Seq> > + inline _GLIBCXX26_CONSTEXPR compare_three_way_result_t<_Seq> > operator<=>(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y) > { return __x.c <=> __y.c; } > #endif > > #if __cplusplus >= 201103L > template<typename _Tp, typename _Seq> > - inline > + inline _GLIBCXX26_CONSTEXPR > #if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11 > // Constrained free swap overload, see p0185r1 > typename enable_if<__is_swappable<_Seq>::value>::type > @@ -611,14 +621,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > priority_queue() > : c(), comp() { } > > - _GLIBCXX26_CONSTEXPR > - explicit > + explicit _GLIBCXX26_CONSTEXPR > priority_queue(const _Compare& __x, const _Sequence& __s) > : c(__s), comp(__x) > { std::make_heap(c.begin(), c.end(), comp); } > > - _GLIBCXX26_CONSTEXPR > - explicit > + explicit _GLIBCXX26_CONSTEXPR > priority_queue(const _Compare& __x, _Sequence&& __s = _Sequence()) > : c(std::move(__s)), comp(__x) > { std::make_heap(c.begin(), c.end(), comp); } > @@ -633,8 +641,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > : c(std::move(__q.c)), comp(std::move(__q.comp)) > { __q.c.clear(); } > > - _GLIBCXX26_CONSTEXPR > - priority_queue& > + _GLIBCXX26_CONSTEXPR priority_queue& > operator=(priority_queue&& __q) > noexcept(__and_<is_nothrow_move_assignable<_Sequence>, > is_nothrow_move_assignable<_Compare>>::value) > @@ -646,8 +653,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > } > > template<typename _Alloc, typename _Requires = _Uses<_Alloc>> > - _GLIBCXX26_CONSTEXPR > - explicit > + explicit _GLIBCXX26_CONSTEXPR > priority_queue(const _Alloc& __a) > : c(__a), comp() { } > > @@ -830,14 +836,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > /** > * Returns true if the %queue is empty. > */ > - _GLIBCXX_NODISCARD _GLIBCXX26_CONSTEXPR > - bool > + _GLIBCXX_NODISCARD > + _GLIBCXX26_CONSTEXPR bool > empty() const > { return c.empty(); } > > /** Returns the number of elements in the %queue. */ > - _GLIBCXX_NODISCARD _GLIBCXX26_CONSTEXPR > - size_type > + _GLIBCXX_NODISCARD > + _GLIBCXX26_CONSTEXPR size_type > size() const > { return c.size(); } > > @@ -845,8 +851,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > * Returns a read-only (constant) reference to the data at the > first > * element of the %queue. > */ > - _GLIBCXX_NODISCARD _GLIBCXX26_CONSTEXPR > - const_reference > + _GLIBCXX_NODISCARD > + _GLIBCXX26_CONSTEXPR const_reference > top() const > { > __glibcxx_requires_nonempty(); > @@ -861,8 +867,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > * The time complexity of the operation depends on the underlying > * sequence. > */ > - _GLIBCXX26_CONSTEXPR > - void > + _GLIBCXX26_CONSTEXPR void > push(const value_type& __x) > { > c.push_back(__x); > @@ -870,8 +875,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > } > > #if __cplusplus >= 201103L > - _GLIBCXX26_CONSTEXPR > - void > + _GLIBCXX26_CONSTEXPR void > push(value_type&& __x) > { > c.push_back(std::move(__x)); > @@ -879,8 +883,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > } > > template<typename... _Args> > - _GLIBCXX26_CONSTEXPR > - void > + _GLIBCXX26_CONSTEXPR void > emplace(_Args&&... __args) > { > c.emplace_back(std::forward<_Args>(__args)...); > @@ -890,8 +893,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > > #if __glibcxx_containers_ranges // C++ >= 23 > template<__detail::__container_compatible_range<_Tp> _Rg> > - _GLIBCXX26_CONSTEXPR > - void > + _GLIBCXX26_CONSTEXPR void > push_range(_Rg&& __rg) > { > if constexpr (requires { > c.append_range(std::forward<_Rg>(__rg)); }) > @@ -913,8 +915,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > * data is needed, it should be retrieved before pop() is > * called. > */ > - _GLIBCXX26_CONSTEXPR > - void > + _GLIBCXX26_CONSTEXPR void > pop() > { > __glibcxx_requires_nonempty(); > @@ -923,8 +924,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > } > > #if __cplusplus >= 201103L > - _GLIBCXX26_CONSTEXPR > - void > + _GLIBCXX26_CONSTEXPR void > swap(priority_queue& __pq) > noexcept(__and_< > #if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11 > @@ -992,8 +992,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > > #if __cplusplus >= 201103L > template<typename _Tp, typename _Sequence, typename _Compare> > - _GLIBCXX26_CONSTEXPR > - inline > + inline _GLIBCXX26_CONSTEXPR > #if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11 > // Constrained free swap overload, see p0185r1 > typename enable_if<__and_<__is_swappable<_Sequence>, > diff --git a/libstdc++-v3/include/bits/stl_uninitialized.h > b/libstdc++-v3/include/bits/stl_uninitialized.h > index a8791a66ae8..a418c079d2a 100644 > --- a/libstdc++-v3/include/bits/stl_uninitialized.h > +++ b/libstdc++-v3/include/bits/stl_uninitialized.h > @@ -666,6 +666,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > #if __cplusplus >= 201103L > template<typename _ITp, typename _IRef, typename _IPtr, typename _OTp, > typename _Tp> > + _GLIBCXX26_CONSTEXPR > _GLIBCXX_STD_C::_Deque_iterator<_OTp, _OTp&, _OTp*> > __uninitialized_copy_a( > _GLIBCXX_STD_C::_Deque_iterator<_ITp, _IRef, _IPtr> __first, > @@ -674,6 +675,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > allocator<_Tp>&); > > template<typename _Iter, typename _OTp, typename _Tp> > + _GLIBCXX26_CONSTEXPR > __enable_if_t<__is_random_access_iter<_Iter>::value, > _GLIBCXX_STD_C::_Deque_iterator<_OTp, _OTp&, _OTp*>> > __uninitialized_copy_a(_Iter __first, _Iter __last, > @@ -682,6 +684,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > > template<typename _ITp, typename _IRef, typename _IPtr, typename _OTp, > typename _Tp> > + _GLIBCXX26_CONSTEXPR > _GLIBCXX_STD_C::_Deque_iterator<_OTp, _OTp&, _OTp*> > __uninitialized_move_a( > _GLIBCXX_STD_C::_Deque_iterator<_ITp, _IRef, _IPtr> __first, > @@ -1003,7 +1006,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > // Fills [first, last) with value_types constructed by the allocator > // alloc, with no arguments passed to the construct call. > template<typename _ForwardIterator, typename _Allocator> > - void > + _GLIBCXX20_CONSTEXPR void > __uninitialized_default_a(_ForwardIterator __first, > _ForwardIterator __last, > _Allocator& __alloc) > @@ -1018,7 +1021,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > > #if _GLIBCXX_HOSTED > template<typename _ForwardIterator, typename _Tp> > - inline void > + inline _GLIBCXX20_CONSTEXPR void > __uninitialized_default_a(_ForwardIterator __first, > _ForwardIterator __last, > allocator<_Tp>&) > diff --git a/libstdc++-v3/include/bits/version.def > b/libstdc++-v3/include/bits/version.def > index d14d4f4ef25..b7349fdef63 100644 > --- a/libstdc++-v3/include/bits/version.def > +++ b/libstdc++-v3/include/bits/version.def > @@ -1463,6 +1463,24 @@ ftms = { > }; > }; > > +ftms = { > + name = constexpr_deque; > + values = { > + v = 202502; > + cxxmin = 26; > + hosted = yes; > + }; > +}; > + > +ftms = { > + name = constexpr_queue; > + values = { > + v = 202502; > + cxxmin = 26; > + hosted = yes; > + }; > +}; > + > ftms = { > name = constrained_equality; > values = { > diff --git a/libstdc++-v3/include/bits/version.h > b/libstdc++-v3/include/bits/version.h > index 9a73f771e72..142d550279f 100644 > --- a/libstdc++-v3/include/bits/version.h > +++ b/libstdc++-v3/include/bits/version.h > @@ -1596,6 +1596,26 @@ > #endif /* !defined(__cpp_lib_constexpr_vector) */ > #undef __glibcxx_want_constexpr_vector > > +#if !defined(__cpp_lib_constexpr_deque) > +# if (__cplusplus > 202302L) && _GLIBCXX_HOSTED > +# define __glibcxx_constexpr_deque 202502L > +# if defined(__glibcxx_want_all) || > defined(__glibcxx_want_constexpr_deque) > +# define __cpp_lib_constexpr_deque 202502L > +# endif > +# endif > +#endif /* !defined(__cpp_lib_constexpr_deque) */ > +#undef __glibcxx_want_constexpr_deque > + > +#if !defined(__cpp_lib_constexpr_queue) > +# if (__cplusplus > 202302L) && _GLIBCXX_HOSTED > +# define __glibcxx_constexpr_queue 202502L > +# if defined(__glibcxx_want_all) || > defined(__glibcxx_want_constexpr_queue) > +# define __cpp_lib_constexpr_queue 202502L > +# endif > +# endif > +#endif /* !defined(__cpp_lib_constexpr_queue) */ > +#undef __glibcxx_want_constexpr_queue > + > #if !defined(__cpp_lib_constrained_equality) > # if (__cplusplus > 202002L) && (__glibcxx_three_way_comparison) > # define __glibcxx_constrained_equality 202411L > diff --git a/libstdc++-v3/include/debug/deque > b/libstdc++-v3/include/debug/deque > index 00b4220051e..9a1f493e494 100644 > --- a/libstdc++-v3/include/debug/deque > +++ b/libstdc++-v3/include/debug/deque > @@ -110,12 +110,15 @@ namespace __debug > deque(const deque&) = default; > deque(deque&&) = default; > > + _GLIBCXX26_CONSTEXPR > deque(const deque& __d, const __type_identity_t<_Allocator>& __a) > : _Base(__d, __a) { } > > + _GLIBCXX26_CONSTEXPR > deque(deque&& __d, const __type_identity_t<_Allocator>& __a) > : _Safe(std::move(__d)), _Base(std::move(__d), __a) { } > > + _GLIBCXX26_CONSTEXPR > deque(initializer_list<value_type> __l, > const allocator_type& __a = allocator_type()) > : _Base(__l, __a) { } > @@ -123,15 +126,16 @@ namespace __debug > ~deque() = default; > #endif > > - explicit > + explicit _GLIBCXX26_CONSTEXPR > deque(const _Allocator& __a) > : _Base(__a) { } > > #if __cplusplus >= 201103L > - explicit > + explicit _GLIBCXX26_CONSTEXPR > deque(size_type __n, const _Allocator& __a = _Allocator()) > : _Base(__n, __a) { } > > + _GLIBCXX26_CONSTEXPR > deque(size_type __n, const __type_identity_t<_Tp>& __value, > const _Allocator& __a = _Allocator()) > : _Base(__n, __value, __a) { } > @@ -145,23 +149,26 @@ namespace __debug > #if __cplusplus >= 201103L > template<class _InputIterator, > typename = std::_RequireInputIter<_InputIterator>> > + _GLIBCXX26_CONSTEXPR > #else > template<class _InputIterator> > #endif > deque(_InputIterator __first, _InputIterator __last, > const _Allocator& __a = _Allocator()) > - : _Base(__gnu_debug::__base( > - __glibcxx_check_valid_constructor_range(__first, > __last)), > + : _Base(__gnu_debug::__base(std::__is_constant_evaluated() ? > __first > + : __glibcxx_check_valid_constructor_range(__first, > __last)), > __gnu_debug::__base(__last), __a) > { } > > #if __glibcxx_containers_ranges // C++ >= 23 > template<__detail::__container_compatible_range<_Tp> _Rg> > + _GLIBCXX26_CONSTEXPR > deque(from_range_t, _Rg&& __rg, const _Allocator& __a = > _Allocator()) > : _Base(from_range, std::forward<_Rg>(__rg), __a) > { } > #endif > > + _GLIBCXX26_CONSTEXPR > deque(_Base_ref __x) > : _Base(__x._M_ref) { } > > @@ -172,11 +179,12 @@ namespace __debug > deque& > operator=(deque&&) = default; > > - deque& > + _GLIBCXX26_CONSTEXPR deque& > operator=(initializer_list<value_type> __l) > { > _Base::operator=(__l); > - this->_M_invalidate_all(); > + if (!std::__is_constant_evaluated()) > + this->_M_invalidate_all(); > return *this; > } > #endif > @@ -187,9 +195,13 @@ namespace __debug > #else > template<class _InputIterator> > #endif > - void > + _GLIBCXX26_CONSTEXPR void > assign(_InputIterator __first, _InputIterator __last) > { > + if (std::__is_constant_evaluated()) > + return _Base::assign(__gnu_debug::__unsafe(__first), > + __gnu_debug::__unsafe(__last)); > + > typename __gnu_debug::_Distance_traits<_InputIterator>::__type > __dist; > __glibcxx_check_valid_range2(__first, __last, __dist); > if (__dist.second >= __gnu_debug::__dp_sign) > @@ -201,29 +213,32 @@ namespace __debug > this->_M_invalidate_all(); > } > > - void > + _GLIBCXX26_CONSTEXPR void > assign(size_type __n, const _Tp& __t) > { > _Base::assign(__n, __t); > - this->_M_invalidate_all(); > + if (!std::__is_constant_evaluated()) > + this->_M_invalidate_all(); > } > > #if __cplusplus >= 201103L > - void > + _GLIBCXX26_CONSTEXPR void > assign(initializer_list<value_type> __l) > { > _Base::assign(__l); > - this->_M_invalidate_all(); > + if (!std::__is_constant_evaluated()) > + this->_M_invalidate_all(); > } > #endif > > #if __glibcxx_containers_ranges // C++ >= 23 > template<std::__detail::__container_compatible_range<_Tp> _Rg> > - void > + _GLIBCXX26_CONSTEXPR void > assign_range(_Rg&& __rg) > { > _Base::assign_range(std::forward<_Rg>(__rg)); > - this->_M_invalidate_all(); > + if (!std::__is_constant_evaluated()) > + this->_M_invalidate_all(); > } > #endif > > @@ -231,69 +246,69 @@ namespace __debug > > // iterators: > _GLIBCXX_NODISCARD > - iterator > + _GLIBCXX26_CONSTEXPR iterator > begin() _GLIBCXX_NOEXCEPT > { return iterator(_Base::begin(), this); } > > _GLIBCXX_NODISCARD > - const_iterator > + _GLIBCXX26_CONSTEXPR const_iterator > begin() const _GLIBCXX_NOEXCEPT > { return const_iterator(_Base::begin(), this); } > > _GLIBCXX_NODISCARD > - iterator > + _GLIBCXX26_CONSTEXPR iterator > end() _GLIBCXX_NOEXCEPT > { return iterator(_Base::end(), this); } > > _GLIBCXX_NODISCARD > - const_iterator > + _GLIBCXX26_CONSTEXPR const_iterator > end() const _GLIBCXX_NOEXCEPT > { return const_iterator(_Base::end(), this); } > > _GLIBCXX_NODISCARD > - reverse_iterator > + _GLIBCXX26_CONSTEXPR reverse_iterator > rbegin() _GLIBCXX_NOEXCEPT > { return reverse_iterator(end()); } > > _GLIBCXX_NODISCARD > - const_reverse_iterator > + _GLIBCXX26_CONSTEXPR const_reverse_iterator > rbegin() const _GLIBCXX_NOEXCEPT > { return const_reverse_iterator(end()); } > > _GLIBCXX_NODISCARD > - reverse_iterator > + _GLIBCXX26_CONSTEXPR reverse_iterator > rend() _GLIBCXX_NOEXCEPT > { return reverse_iterator(begin()); } > > _GLIBCXX_NODISCARD > - const_reverse_iterator > + _GLIBCXX26_CONSTEXPR const_reverse_iterator > rend() const _GLIBCXX_NOEXCEPT > { return const_reverse_iterator(begin()); } > > #if __cplusplus >= 201103L > [[__nodiscard__]] > - const_iterator > + _GLIBCXX26_CONSTEXPR const_iterator > cbegin() const noexcept > { return const_iterator(_Base::begin(), this); } > > [[__nodiscard__]] > - const_iterator > + _GLIBCXX26_CONSTEXPR const_iterator > cend() const noexcept > { return const_iterator(_Base::end(), this); } > > [[__nodiscard__]] > - const_reverse_iterator > + _GLIBCXX26_CONSTEXPR const_reverse_iterator > crbegin() const noexcept > { return const_reverse_iterator(end()); } > > [[__nodiscard__]] > - const_reverse_iterator > + _GLIBCXX26_CONSTEXPR const_reverse_iterator > crend() const noexcept > { return const_reverse_iterator(begin()); } > #endif > > private: > - void > + _GLIBCXX26_CONSTEXPR void > _M_invalidate_after_nth(difference_type __n) > { > typedef __gnu_debug::_After_nth_from<_Base_const_iterator> > _After_nth; > @@ -306,9 +321,12 @@ namespace __debug > using _Base::max_size; > > #if __cplusplus >= 201103L > - void > + _GLIBCXX26_CONSTEXPR void > resize(size_type __sz) > { > + if (std::__is_constant_evaluated()) > + return _Base::resize(__sz); > + > bool __invalidate_all = __sz > this->size(); > if (__sz < this->size()) > this->_M_invalidate_after_nth(__sz); > @@ -319,9 +337,12 @@ namespace __debug > this->_M_invalidate_all(); > } > > - void > + _GLIBCXX26_CONSTEXPR void > resize(size_type __sz, const _Tp& __c) > { > + if (std::__is_constant_evaluated()) > + return _Base::resize(__sz, __c); > + > bool __invalidate_all = __sz > this->size(); > if (__sz < this->size()) > this->_M_invalidate_after_nth(__sz); > @@ -347,11 +368,12 @@ namespace __debug > #endif > > #if __cplusplus >= 201103L > - void > + _GLIBCXX26_CONSTEXPR void > shrink_to_fit() noexcept > { > if (_Base::_M_shrink_to_fit()) > - this->_M_invalidate_all(); > + if (!std::__is_constant_evaluated()) > + this->_M_invalidate_all(); > } > #endif > > @@ -359,7 +381,7 @@ namespace __debug > > // element access: > _GLIBCXX_NODISCARD > - reference > + _GLIBCXX26_CONSTEXPR reference > operator[](size_type __n) _GLIBCXX_NOEXCEPT > { > __glibcxx_check_subscript(__n); > @@ -367,7 +389,7 @@ namespace __debug > } > > _GLIBCXX_NODISCARD > - const_reference > + _GLIBCXX26_CONSTEXPR const_reference > operator[](size_type __n) const _GLIBCXX_NOEXCEPT > { > __glibcxx_check_subscript(__n); > @@ -377,7 +399,7 @@ namespace __debug > using _Base::at; > > _GLIBCXX_NODISCARD > - reference > + _GLIBCXX26_CONSTEXPR reference > front() _GLIBCXX_NOEXCEPT > { > __glibcxx_check_nonempty(); > @@ -385,7 +407,7 @@ namespace __debug > } > > _GLIBCXX_NODISCARD > - const_reference > + _GLIBCXX26_CONSTEXPR const_reference > front() const _GLIBCXX_NOEXCEPT > { > __glibcxx_check_nonempty(); > @@ -393,7 +415,7 @@ namespace __debug > } > > _GLIBCXX_NODISCARD > - reference > + _GLIBCXX26_CONSTEXPR reference > back() _GLIBCXX_NOEXCEPT > { > __glibcxx_check_nonempty(); > @@ -401,7 +423,7 @@ namespace __debug > } > > _GLIBCXX_NODISCARD > - const_reference > + _GLIBCXX26_CONSTEXPR const_reference > back() const _GLIBCXX_NOEXCEPT > { > __glibcxx_check_nonempty(); > @@ -409,14 +431,14 @@ namespace __debug > } > > // 23.2.1.3 modifiers: > - void > + _GLIBCXX26_CONSTEXPR void > push_front(const _Tp& __x) > { > _Base::push_front(__x); > this->_M_invalidate_all(); > } > > - void > + _GLIBCXX26_CONSTEXPR void > push_back(const _Tp& __x) > { > _Base::push_back(__x); > @@ -424,24 +446,25 @@ namespace __debug > } > > #if __cplusplus >= 201103L > - void > + _GLIBCXX26_CONSTEXPR void > push_front(_Tp&& __x) > { emplace_front(std::move(__x)); } > > - void > + _GLIBCXX26_CONSTEXPR void > push_back(_Tp&& __x) > { emplace_back(std::move(__x)); } > > template<typename... _Args> > #if __cplusplus > 201402L > - reference > + _GLIBCXX26_CONSTEXPR reference > #else > void > #endif > emplace_front(_Args&&... __args) > { > _Base::emplace_front(std::forward<_Args>(__args)...); > - this->_M_invalidate_all(); > + if (!std::__is_constant_evaluated()) > + this->_M_invalidate_all(); > #if __cplusplus > 201402L > return front(); > #endif > @@ -449,23 +472,29 @@ namespace __debug > > template<typename... _Args> > #if __cplusplus > 201402L > - reference > + _GLIBCXX26_CONSTEXPR reference > #else > void > #endif > emplace_back(_Args&&... __args) > { > _Base::emplace_back(std::forward<_Args>(__args)...); > - this->_M_invalidate_all(); > + if (!std::__is_constant_evaluated()) > + this->_M_invalidate_all(); > #if __cplusplus > 201402L > return back(); > #endif > } > > template<typename... _Args> > - iterator > + _GLIBCXX26_CONSTEXPR iterator > emplace(const_iterator __position, _Args&&... __args) > { > + if (std::__is_constant_evaluated()) > + return iterator(_Base::emplace(__position.base(), > + std::forward<_Args>(__args)...), > + this); > + > __glibcxx_check_insert(__position); > _Base_iterator __res = _Base::emplace(__position.base(), > > std::forward<_Args>(__args)...); > @@ -474,13 +503,16 @@ namespace __debug > } > #endif > > - iterator > + _GLIBCXX26_CONSTEXPR iterator > #if __cplusplus >= 201103L > insert(const_iterator __position, const _Tp& __x) > #else > insert(iterator __position, const _Tp& __x) > #endif > { > + if (std::__is_constant_evaluated()) > + return iterator(_Base::insert(__position.base(), __x), this); > + > __glibcxx_check_insert(__position); > _Base_iterator __res = _Base::insert(__position.base(), __x); > this->_M_invalidate_all(); > @@ -488,13 +520,16 @@ namespace __debug > } > > #if __cplusplus >= 201103L > - iterator > + _GLIBCXX26_CONSTEXPR iterator > insert(const_iterator __position, _Tp&& __x) > { return emplace(__position, std::move(__x)); } > > - iterator > + _GLIBCXX26_CONSTEXPR iterator > insert(const_iterator __position, initializer_list<value_type> __l) > { > + if (std::__is_constant_evaluated()) > + return iterator(_Base::insert(__position.base(), __l), this); > + > __glibcxx_check_insert(__position); > _Base_iterator __res = _Base::insert(__position.base(), __l); > this->_M_invalidate_all(); > @@ -503,9 +538,12 @@ namespace __debug > #endif > > #if __cplusplus >= 201103L > - iterator > + _GLIBCXX26_CONSTEXPR iterator > insert(const_iterator __position, size_type __n, const _Tp& __x) > { > + if (std::__is_constant_evaluated()) > + return iterator(_Base::insert(__position.base(), __n, __x), > this); > + > __glibcxx_check_insert(__position); > _Base_iterator __res = _Base::insert(__position.base(), __n, __x); > this->_M_invalidate_all(); > @@ -524,10 +562,15 @@ namespace __debug > #if __cplusplus >= 201103L > template<class _InputIterator, > typename = std::_RequireInputIter<_InputIterator>> > - iterator > + _GLIBCXX26_CONSTEXPR iterator > insert(const_iterator __position, > _InputIterator __first, _InputIterator __last) > { > + if (std::__is_constant_evaluated()) > + return iterator(_Base::insert(__position.base(), > + __gnu_debug::__unsafe(__first), > + __gnu_debug::__unsafe(__last)), > this); > + > typename __gnu_debug::_Distance_traits<_InputIterator>::__type > __dist; > __glibcxx_check_insert_range(__position, __first, __last, > __dist); > _Base_iterator __res; > @@ -563,54 +606,66 @@ namespace __debug > > #if __glibcxx_containers_ranges // C++ >= 23 > template<__detail::__container_compatible_range<_Tp> _Rg> > - iterator > + _GLIBCXX26_CONSTEXPR iterator > insert_range(const_iterator __pos, _Rg&& __rg) > { > auto __res = _Base::insert_range(__pos.base(), > std::forward<_Rg>(__rg)); > - this->_M_invalidate_all(); > + if (!std::__is_constant_evaluated()) > + this->_M_invalidate_all(); > return iterator(__res, this); > } > > template<std::__detail::__container_compatible_range<_Tp> _Rg> > - void > + _GLIBCXX26_CONSTEXPR void > prepend_range(_Rg&& __rg) > { > _Base::prepend_range(std::forward<_Rg>(__rg)); > - this->_M_invalidate_all(); > + if (!std::__is_constant_evaluated()) > + this->_M_invalidate_all(); > } > > template<std::__detail::__container_compatible_range<_Tp> _Rg> > - void > + _GLIBCXX26_CONSTEXPR void > append_range(_Rg&& __rg) > { > _Base::append_range(std::forward<_Rg>(__rg)); > - this->_M_invalidate_all(); > + if (!std::__is_constant_evaluated()) > + this->_M_invalidate_all(); > } > #endif > > - void > + _GLIBCXX26_CONSTEXPR void > pop_front() _GLIBCXX_NOEXCEPT > { > - __glibcxx_check_nonempty(); > - this->_M_invalidate_if(_Equal(_Base::begin())); > + if (!std::__is_constant_evaluated()) > + { > + __glibcxx_check_nonempty(); > + this->_M_invalidate_if(_Equal(_Base::begin())); > + } > _Base::pop_front(); > } > > - void > + _GLIBCXX26_CONSTEXPR void > pop_back() _GLIBCXX_NOEXCEPT > { > - __glibcxx_check_nonempty(); > - this->_M_invalidate_if(_Equal(--_Base::end())); > + if (!std::__is_constant_evaluated()) > + { > + __glibcxx_check_nonempty(); > + this->_M_invalidate_if(_Equal(_Base::begin())); > + } > _Base::pop_back(); > } > > - iterator > + _GLIBCXX26_CONSTEXPR iterator > #if __cplusplus >= 201103L > erase(const_iterator __position) > #else > - erase(iterator __position) > + erase(iterator __position) > #endif > { > + if (std::__is_constant_evaluated()) > + return iterator(_Base::erase(__position.base()), this); > + > __glibcxx_check_erase(__position); > #if __cplusplus >= 201103L > _Base_const_iterator __victim = __position.base(); > @@ -630,13 +685,16 @@ namespace __debug > } > } > > - iterator > + _GLIBCXX26_CONSTEXPR iterator > #if __cplusplus >= 201103L > erase(const_iterator __first, const_iterator __last) > #else > erase(iterator __first, iterator __last) > #endif > { > + if (std::__is_constant_evaluated()) > + return iterator(_Base::erase(__first.base(), __last.base()), > this); > + > // _GLIBCXX_RESOLVE_LIB_DEFECTS > // 151. can't currently clear() empty container > __glibcxx_check_erase_range(__first, __last); > @@ -677,25 +735,27 @@ namespace __debug > } > } > > - void > + _GLIBCXX26_CONSTEXPR void > swap(deque& __x) > _GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) ) > { > - _Safe::_M_swap(__x); > + if (!std::__is_constant_evaluated()) > + _Safe::_M_swap(__x); > _Base::swap(__x); > } > > - void > + _GLIBCXX26_CONSTEXPR void > clear() _GLIBCXX_NOEXCEPT > { > _Base::clear(); > - this->_M_invalidate_all(); > + if (!std::__is_constant_evaluated()) > + this->_M_invalidate_all(); > } > > - _Base& > + _GLIBCXX26_CONSTEXPR _Base& > _M_base() _GLIBCXX_NOEXCEPT { return *this; } > > - const _Base& > + _GLIBCXX26_CONSTEXPR const _Base& > _M_base() const _GLIBCXX_NOEXCEPT { return *this; } > }; > > @@ -722,7 +782,7 @@ namespace __debug > #endif > > template<typename _Tp, typename _Alloc> > - inline bool > + inline _GLIBCXX26_CONSTEXPR bool > operator==(const deque<_Tp, _Alloc>& __lhs, > const deque<_Tp, _Alloc>& __rhs) > { return __lhs._M_base() == __rhs._M_base(); } > @@ -765,7 +825,7 @@ namespace __debug > #endif // three-way comparison > > template<typename _Tp, typename _Alloc> > - inline void > + inline _GLIBCXX26_CONSTEXPR void > swap(deque<_Tp, _Alloc>& __lhs, deque<_Tp, _Alloc>& __rhs) > _GLIBCXX_NOEXCEPT_IF(noexcept(__lhs.swap(__rhs))) > { __lhs.swap(__rhs); } > @@ -775,14 +835,14 @@ namespace __debug > #ifdef __glibcxx_erase_if // C++ >= 20 && HOSTED > _GLIBCXX_BEGIN_NAMESPACE_VERSION > template<typename _Tp, typename _Alloc, typename _Predicate> > - inline typename __debug::deque<_Tp, _Alloc>::size_type > + inline _GLIBCXX26_CONSTEXPR typename __debug::deque<_Tp, > _Alloc>::size_type > erase_if(__debug::deque<_Tp, _Alloc>& __cont, _Predicate __pred) > { > return __detail::__erase_if(__cont, __cont._M_base(), > std::move(__pred)); > } > > template<typename _Tp, typename _Alloc, typename _Up = _Tp> > - inline typename __debug::deque<_Tp, _Alloc>::size_type > + inline _GLIBCXX26_CONSTEXPR typename __debug::deque<_Tp, > _Alloc>::size_type > erase(__debug::deque<_Tp, _Alloc>& __cont, const _Up& __value) > { return std::erase_if(__cont, > __gnu_cxx::__ops::__equal_to(__value)); } > _GLIBCXX_END_NAMESPACE_VERSION > diff --git a/libstdc++-v3/include/std/deque > b/libstdc++-v3/include/std/deque > index 3b2f34fc707..f889c2cf4c7 100644 > --- a/libstdc++-v3/include/std/deque > +++ b/libstdc++-v3/include/std/deque > @@ -73,6 +73,7 @@ > > #define __glibcxx_want_algorithm_default_value_type > #define __glibcxx_want_allocator_traits_is_always_equal > +#define __glibcxx_want_constexpr_deque > #define __glibcxx_want_containers_ranges > #define __glibcxx_want_erase_if > #define __glibcxx_want_hardened_deque > @@ -103,13 +104,15 @@ namespace std _GLIBCXX_VISIBILITY(default) > _GLIBCXX_BEGIN_NAMESPACE_VERSION > > template<typename _Tp, typename _Alloc, typename _Predicate> > - inline typename _GLIBCXX_STD_C::deque<_Tp, _Alloc>::size_type > + inline _GLIBCXX26_CONSTEXPR > + typename _GLIBCXX_STD_C::deque<_Tp, _Alloc>::size_type > erase_if(_GLIBCXX_STD_C::deque<_Tp, _Alloc>& __cont, _Predicate > __pred) > { return __detail::__erase_if(__cont, __cont, std::move(__pred)); } > > template<typename _Tp, typename _Alloc, > typename _Up _GLIBCXX26_DEF_VAL_T(_Tp)> > - inline typename _GLIBCXX_STD_C::deque<_Tp, _Alloc>::size_type > + inline _GLIBCXX26_CONSTEXPR > + typename _GLIBCXX_STD_C::deque<_Tp, _Alloc>::size_type > erase(_GLIBCXX_STD_C::deque<_Tp, _Alloc>& __cont, const _Up& __value) > { return std::erase_if(__cont, > __gnu_cxx::__ops::__equal_to(__value)); } > > diff --git a/libstdc++-v3/include/std/queue > b/libstdc++-v3/include/std/queue > index 13e25482125..061e7cae5d3 100644 > --- a/libstdc++-v3/include/std/queue > +++ b/libstdc++-v3/include/std/queue > @@ -63,6 +63,7 @@ > > #define __glibcxx_want_adaptor_iterator_pair_constructor > #define __glibcxx_want_containers_ranges > +#define __glibcxx_want_constexpr_queue > #include <bits/version.h> > > #include <deque> > @@ -74,6 +75,12 @@ > #ifdef __glibcxx_format_ranges // C++ >= 23 && HOSTED > #include <bits/formatfwd.h> > > +#ifdef __glibcxx_constexpr_format // C++ >= 26 && HOSTED && CXX11 strings > +# define _GLIBCXX_CONSTEXPR_FORMAT constexpr > +#else > +# define _GLIBCXX_CONSTEXPR_FORMAT > +#endif > + > namespace std _GLIBCXX_VISIBILITY(default) > { > _GLIBCXX_BEGIN_NAMESPACE_VERSION > @@ -99,6 +106,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > // Standard declares this as template accepting unconstrained > // FormatContext type. > template<typename _Out> > + _GLIBCXX_CONSTEXPR_FORMAT > typename basic_format_context<_Out, _CharT>::iterator > format(__maybe_const_adaptor& __a, > basic_format_context<_Out, _CharT>& __fc) const > @@ -141,6 +149,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > // Standard declares this as template accepting unconstrained > // FormatContext type. > template<typename _Out> > + _GLIBCXX_CONSTEXPR_FORMAT > typename basic_format_context<_Out, _CharT>::iterator > format(__maybe_const_adaptor& __a, > basic_format_context<_Out, _CharT>& __fc) const > @@ -163,6 +172,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > priority_queue<_Tp, _Container, _Comparator>> = false; > #endif > > +#undef _GLIBCXX_CONSTEXPR_FORMAT > + > _GLIBCXX_END_NAMESPACE_VERSION > } // namespace std > #endif // __glibcxx_format_ranges > diff --git a/libstdc++-v3/testsuite/23_containers/deque/constexpr.cc > b/libstdc++-v3/testsuite/23_containers/deque/constexpr.cc > new file mode 100644 > index 00000000000..50e45a639ab > --- /dev/null > +++ b/libstdc++-v3/testsuite/23_containers/deque/constexpr.cc > @@ -0,0 +1,334 @@ > +// { dg-do compile { target c++26 } } > + > +#include <deque> > + > +#ifndef __cpp_lib_constexpr_deque > +#error "Feature test macro for constexpr deque is missing in <deque>" > +#elif __cpp_lib_constexpr_deque != 202502L > +# error "Feature test macro for constexpr deque has wrong value in > <deque>" > +#endif > + > +#include <ranges> > +#include <numeric> > +#include <testsuite_hooks.h> > +#include <testsuite_iterators.h> > +#include <testsuite_allocator.h> > + > +using namespace __gnu_test; > + > +template<typename Alloc> > +constexpr bool > +ctor_tests() > +{ > + Alloc alloc; > + > + std::deque<int, Alloc> dq2(alloc); > + std::deque<int, Alloc> dq3(4, alloc); > + VERIFY( dq3.front() == 0 ); > + VERIFY( dq3.size() == 4 ); > + std::deque<int, Alloc> dq4(4, 5, alloc); > + VERIFY( dq4.front() == 5 ); > + VERIFY( dq4.size() == 4 ); > + > + auto rg = {2, 3, 5, 7}; > + std::deque<int> dq5(rg.begin(), rg.end()); > + VERIFY( dq5.front() == 2 ); > + VERIFY( dq5.back() == 7 ); > + VERIFY( dq5.size() == 4 ); > + > + std::deque<int> dq6(std::from_range, rg); > + VERIFY( dq6 == dq5 ); > + > + std::deque<int> dq1{1, 2, 3}; > + std::deque<int> dq7(dq1); > + VERIFY( dq7 == dq1 ); > + std::deque<int>dq8(std::move(dq1)); > + VERIFY( dq8 == dq7 ); > + > + dq2.insert_range(dq2.begin(), rg); > + std::deque<int, Alloc> dq9(dq2, alloc); > + std::deque<int, Alloc> dq10(std::move(dq2), alloc); > + VERIFY( dq9 == dq10 ); > + std::deque<int, Alloc> dq11(rg, alloc); > + VERIFY( dq11 == dq10 ); > + > + return true; > +} > +static_assert( ctor_tests<std::allocator<int>>() ); > +static_assert( ctor_tests<SimpleAllocator<int>>() ); > + > +constexpr bool > +insert_tests() > +{ > + std::deque<int> dq1 {}; > + > + auto rg = {1, 2, 3, 4, 5}; > + > + dq1.insert(dq1.begin() , 1); > + dq1.insert(dq1.end(), 2); > + VERIFY( dq1.size() == 2 ); > + VERIFY( dq1.front() == 1 ); > + VERIFY( dq1.back() == 2 ); > + > + dq1.insert(dq1.end(), 1, 3); > + > + dq1.insert(dq1.end(), rg.begin() + 3, rg.end()); > + > + VERIFY( dq1[0] == 1 ); > + VERIFY( dq1[1] == 2 ); > + VERIFY( dq1[2] == 3 ); > + VERIFY( dq1[3] == 4 ); > + VERIFY( dq1[4] == 5 ); > + dq1.clear(); > + > + dq1.insert(dq1.begin(), rg.begin(), rg.end()); > + VERIFY( dq1[0] == 1 ); > + VERIFY( dq1[1] == 2 ); > + VERIFY( dq1[2] == 3 ); > + VERIFY( dq1[3] == 4 ); > + VERIFY( dq1[4] == 5 ); > + > + dq1.insert_range(dq1.end(), rg); > + VERIFY( dq1[5] == 1 ); > + VERIFY( dq1[6] == 2 ); > + VERIFY( dq1[7] == 3 ); > + VERIFY( dq1[8] == 4 ); > + VERIFY( dq1[9] == 5 ); > + > + std::deque<int>dq2 {2, 3, 5, 7}; > + dq2.erase(dq2.begin()); > + VERIFY( dq2.size() == 3 ); > + dq2.clear(); > + VERIFY( dq2.size() == 0); > + VERIFY( dq2.empty() ); > + > + std::deque<int> dq3, dq4; > + dq3.insert_range(dq3.begin(), rg); > + dq4.append_range(rg); > + VERIFY( dq3 == dq4 ); > + dq3.erase(dq3.begin(), dq3.end()); > + dq3.prepend_range(rg); > + VERIFY( dq3 == dq4 ); > + > + struct S { > + int foo; > + constexpr S (int i, int j) : foo{i + j} {} > + }; > + std::deque<S> dq5 {}; > + dq5.emplace(dq5.end(), 0, 1); > + const S& s1 = dq5.emplace_back(1, 1); > + const S& s2 = dq5.emplace_front(2, 1); > + VERIFY( dq5.front().foo == 3 ); > + VERIFY( dq5.back().foo == 2 ); > + VERIFY( dq5[1].foo == 1 ); > + > + std::deque<int> dq6 {2, 3}; > + dq6.push_front(1); > + dq6.push_back(4); > + VERIFY( dq6.front() == 1); > + VERIFY( dq6.back() == 4 ); > + dq6.pop_front(); > + dq6.pop_back(); > + > + std::deque<int> dq7 {1, 2}; > + dq7.resize(4); > + VERIFY( dq7.back() == 0 ); > + dq7.resize(2); > + VERIFY( dq7.front() == 1 ); > + VERIFY( dq7.back() == 2 ); > + dq7.clear(); > + dq7.resize(2); > + VERIFY( dq7.front() == 0 ); > + VERIFY( dq7.back() == 0 ); > + > + std::deque<int> dq8 {1, 4}; > + dq8.swap(dq6); > + VERIFY( dq6.front() == 1 ); > + VERIFY( dq6.back() == 4 ); > + VERIFY( dq8.front() == 2 ); > + VERIFY( dq8.back() == 3 ); > + > + return true; > +} > + > +static_assert( insert_tests() ); > + > +constexpr bool > +iterators_tests() > +{ > + std::deque<int> dq0 {}; > + VERIFY( dq0.begin() == dq0.end() ); > + dq0.resize(1); > + VERIFY( dq0.begin() != dq0.end() ); > + dq0.resize(2); > + VERIFY( dq0.begin() != dq0.end() ); > + VERIFY( dq0.cbegin() == dq0.begin() ); > + VERIFY( dq0.crbegin() == dq0.rbegin() ); > + VERIFY( dq0.cend() == dq0.end() ); > + VERIFY( dq0.crend() == dq0.rend() ); > + > + auto it = dq0.begin(); > + VERIFY( it[0] == 0 ); > + VERIFY( &*it == &dq0.front() ); > + VERIFY( &it[1] == &dq0[1] ); > + VERIFY( it++ == dq0.begin() ); > + VERIFY( ++it == dq0.end() ); > + VERIFY( (it - 2) == dq0.begin() ); > + VERIFY( (it - dq0.begin()) == 2 ); > + it -= 2; > + it += 1; > + VERIFY( (it + 1) == dq0.end() ); > + VERIFY( (1 + it) == dq0.end() ); > + it = it + 1; > + auto it2 = dq0.begin(); > + std::swap(it, it2); > + VERIFY( it == dq0.begin() ); > + VERIFY( it2 == dq0.end() ); > + > + auto rit = dq0.rbegin(); > + VERIFY( rit[0] == 0 ); > + VERIFY( &*rit == &dq0.back() ); > + VERIFY( &rit[1] == &dq0[0] ); > + VERIFY( rit++ == dq0.rbegin() ); > + VERIFY( ++rit == dq0.rend() ); > + VERIFY( (rit - 2) == dq0.rbegin() ); > + VERIFY( (rit - dq0.rbegin()) == 2 ); > + rit -= 2; > + rit += 1; > + VERIFY( (rit + 1) == dq0.rend() ); > + VERIFY( (1 + rit) == dq0.rend() ); > + rit = rit + 1; > + auto rit2 = dq0.rbegin(); > + std::swap(rit, rit2); > + VERIFY( rit == dq0.rbegin() ); > + VERIFY( rit2 == dq0.rend() ); > + > + return true; > +} > +static_assert( iterators_tests() ); > + > +constexpr bool > +capacity_tests() > +{ > + std::deque<int> dq0 {}; > + VERIFY( dq0.empty() ); > + VERIFY( dq0.max_size() ); > + dq0.push_front(0); > + VERIFY( dq0.size() == 1 ); > + dq0.erase(dq0.begin()); > + dq0.shrink_to_fit(); > + > + return true; > +} > +static_assert( capacity_tests() ); > + > +constexpr bool > +nonmember_tests() > +{ > + std::deque<int> dq0 {0, 1}; > + std::deque<int> dq1 {0, 1}; > + > + VERIFY( (dq0 == dq1) == true ); > + VERIFY( (dq0 != dq1) == false ); > + VERIFY( (dq0 <= dq1) == true ); > + VERIFY( (dq0 >= dq1) == true ); > + VERIFY( (dq0 < dq1) == false ); > + VERIFY( (dq0 > dq1) == false ); > + VERIFY( (dq0 <=> dq1) == 0 ); > + VERIFY( (dq0 <=> dq1) <= 0 ); > + VERIFY( (dq0 <=> dq1) >= 0 ); > + > + std::deque<int> dq2 {2, 4}; > + std::swap(dq1, dq2); > + > + VERIFY( (dq0 == dq1) == false ); > + VERIFY( (dq0 != dq1) == true ); > + VERIFY( (dq0 <= dq1) == true ); > + VERIFY( (dq0 >= dq1) == false ); > + VERIFY( (dq0 < dq1) == true ); > + VERIFY( (dq0 > dq1) == false ); > + VERIFY( (dq0 <=> dq1) != 0 ); > + VERIFY( (dq0 <=> dq1) <= 0 ); > + VERIFY( (dq0 <=> dq1) < 0 ); > + > + std::erase(dq0, 0); > + VERIFY( dq0.front() == 1 ); > + > + std::erase_if(dq1, [](int x) { return x % 2 == 0; }); > + VERIFY( dq1.empty() ); > + return true; > +} > +static_assert( nonmember_tests() ); > + > +template<typename Range> > +constexpr bool > +ranges_test() > +{ > + using Tp = std::ranges::range_value_t<Range>; > + Tp a[] {0, 1, 2, 3, 4, > + 5, 6, 7, 8, 9}; > + > + // Constructor tests > + auto dq1 = std::deque<Tp>(std::from_range, Range(a, a+5)); > + VERIFY( dq1[0] == 0 ); > + VERIFY( dq1[1] == 1 ); > + VERIFY( dq1[2] == 2 ); > + VERIFY( dq1[3] == 3 ); > + VERIFY( dq1[4] == 4 ); > + > + // Insert tests > + std::deque<Tp> dq2; > + dq2.insert_range(dq2.begin(), Range(a, a+5)); > + VERIFY( dq2[0] == 0 ); > + VERIFY( dq2[1] == 1 ); > + VERIFY( dq2[2] == 2 ); > + VERIFY( dq2[3] == 3 ); > + VERIFY( dq2[4] == 4 ); > + > + std::deque<Tp> dq3; > + dq3.assign_range(Range(a, a+5)); > + VERIFY( dq2 == dq3 ); > + > + dq2.insert_range(dq2.end(), Range(a+5, a+10)); > + VERIFY( dq2[5] == 5 ); > + VERIFY( dq2[6] == 6 ); > + VERIFY( dq2[7] == 7 ); > + VERIFY( dq2[8] == 8 ); > + VERIFY( dq2[9] == 9 ); > + > + std::deque<Tp> dq4; > + dq4.prepend_range(Range(a, a+5)); > + dq4.append_range(Range(a+5, a+10)); > + VERIFY( dq2 == dq4 ); > + > + return true; > +} > + > +static_assert( ranges_test<test_forward_range<int>>() ); > +static_assert( ranges_test<test_forward_sized_range<int>>() ); > +static_assert( ranges_test<test_sized_range_sized_sent<int, > forward_iterator_wrapper>>() ); > + > +static_assert( ranges_test<test_input_range<int>>() ); > +static_assert( ranges_test<test_input_sized_range<int>>() ); > +static_assert( ranges_test<test_sized_range_sized_sent<int, > input_iterator_wrapper>>() ); > + > +static_assert( ranges_test<test_range<int, > input_iterator_wrapper_nocopy>>() ); > +static_assert( ranges_test<test_sized_range<int, > input_iterator_wrapper_nocopy>>() ); > +static_assert( ranges_test<test_sized_range_sized_sent<int, > input_iterator_wrapper_nocopy>>() ); > + > +static_assert( ranges_test<test_forward_range<short>>() ); > +static_assert( ranges_test<test_input_range<short>>() ); > + > +// Not lvalue-convertible to int > +struct C { > + constexpr C(int v) : val(v) { } > + constexpr operator int() && { return val; } > + > + friend bool operator==(C c, C b) = default; > + friend constexpr bool operator==(C c, int b) > + { return b == c.val; } > + > + int val; > +}; > +using rvalue_input_range = test_range<C, input_iterator_wrapper_rval>; > +static_assert( ranges_test<rvalue_input_range>() ); > diff --git > a/libstdc++-v3/testsuite/23_containers/headers/deque/synopsis.cc > b/libstdc++-v3/testsuite/23_containers/headers/deque/synopsis.cc > index 48e89592059..447eefd6319 100644 > --- a/libstdc++-v3/testsuite/23_containers/headers/deque/synopsis.cc > +++ b/libstdc++-v3/testsuite/23_containers/headers/deque/synopsis.cc > @@ -21,6 +21,12 @@ > > #include <deque> > > +#if __cplusplus > 202302L > +# define CONSTEXPR constexpr > +#else > +# define CONSTEXPR > +#endif > + > #if __cplusplus >= 201103L > # define NOTHROW(X) noexcept(X) > #else > @@ -31,24 +37,30 @@ namespace std { > template <class T, class Allocator> class deque; > > template <class T, class Allocator> > - bool operator== (const deque<T,Allocator>& x, const > deque<T,Allocator>& y); > + CONSTEXPR bool > + operator== (const deque<T,Allocator>& x, const deque<T,Allocator>& y); > > template <class T, class Allocator> > - bool operator< (const deque<T,Allocator>& x, const > deque<T,Allocator>& y); > + CONSTEXPR bool > + operator< (const deque<T,Allocator>& x, const deque<T,Allocator>& y); > > template <class T, class Allocator> > - bool operator!= (const deque<T,Allocator>& x, const > deque<T,Allocator>& y); > + CONSTEXPR bool > + operator!= (const deque<T,Allocator>& x, const deque<T,Allocator>& y); > > template <class T, class Allocator> > - bool operator> (const deque<T,Allocator>& x, const > deque<T,Allocator>& y); > + CONSTEXPR bool > + operator> (const deque<T,Allocator>& x, const deque<T,Allocator>& y); > > template <class T, class Allocator> > - bool operator>= (const deque<T,Allocator>& x, const > deque<T,Allocator>& y); > + CONSTEXPR bool > + operator>= (const deque<T,Allocator>& x, const deque<T,Allocator>& y); > > template <class T, class Allocator> > - bool operator<= (const deque<T,Allocator>& x, const > deque<T,Allocator>& y); > + CONSTEXPR bool > + operator<= (const deque<T,Allocator>& x, const deque<T,Allocator>& y); > > template <class T, class Allocator> > - void swap(deque<T,Allocator>& x, deque<T,Allocator>& y) > + CONSTEXPR void swap(deque<T,Allocator>& x, deque<T,Allocator>& y) > NOTHROW(noexcept(x.swap(y))); > } > diff --git > a/libstdc++-v3/testsuite/23_containers/priority_queue/constexpr.cc > b/libstdc++-v3/testsuite/23_containers/priority_queue/constexpr.cc > index fe85617416d..9cc6f932adb 100644 > --- a/libstdc++-v3/testsuite/23_containers/priority_queue/constexpr.cc > +++ b/libstdc++-v3/testsuite/23_containers/priority_queue/constexpr.cc > @@ -1,43 +1,238 @@ > // { dg-do compile { target c++26 } } > + > #include <queue> > > -constexpr bool test_constexpr_priority_queue() { > - std::priority_queue<int> pq; > - if (!pq.empty()) return false; > - if (pq.size() != 0) return false; > +#ifndef __cpp_lib_constexpr_queue > +# error "Feature test macro for __cpp_lib_constexpr_queue is missing in > <queue>" > +#elif __cpp_lib_constexpr_queue != 202502L > +# error "Feature test macro for __cpp_lib_constexpr_queue has wrong value > in <queue>" > +#endif > + > +#include <algorithm> > +#include <ranges> > +#include <functional> > +#include <vector> > +#include <numeric> > +#include <testsuite_hooks.h> > +#include <testsuite_iterators.h> > +#include <testsuite_allocator.h> > + > +using namespace __gnu_test; > + > +template<typename Cont, typename Cmp = std::less<int>> > +constexpr bool > +ctor_tests(Cmp cmp = Cmp()) > +{ > + using V = typename Cont::value_type; > + using Alloc = Cont::allocator_type; > + > + V rg[] {2, 3, 5, 7}; > + Cont v0{std::from_range, rg}; > + Cont v1 = v0; > + Cont v2 = v0; > + Alloc alloc; > + auto top_range = * std::ranges::max_element(v0, cmp); > + > + auto eq = [&] (std::priority_queue<V, Cont, Cmp>& l, std::span<V> r) { > + if (l.size() != r.size()) > + return false; > + > + std::vector<V> s(r.begin(), r.end()); > + std::ranges::sort(s, cmp); > + for (auto const& v : s | std::views::reverse) { > + if (v != l.top()) > + return false; > + l.pop(); > + } > + return true; > + }; > + > + std::priority_queue<V, Cont, Cmp> pq1; > + VERIFY( pq1.size() == 0 && pq1.empty() ); > + > + std::priority_queue<V, Cont, Cmp> pq2(cmp); > + VERIFY( pq2.size() == 0 && pq2.empty() ); > + > + std::priority_queue<V, Cont, Cmp> pq3(cmp, v0); > + VERIFY( pq3.size() == 4 && pq3.top() == top_range ); > + > + std::priority_queue<V, Cont, Cmp> pq4(cmp, std::move(v0)); > + VERIFY( pq4.size() == 4 && pq4.top() == top_range ); > > - pq.push(10); > - if (pq.empty()) return false; > - if (pq.size() != 1) return false; > - if (pq.top() != 10) return false; > + std::priority_queue<V, Cont, Cmp> pq5(pq3); > + VERIFY( pq5.top() == pq3.top() ); > + VERIFY( pq5.size() == pq3.size() ); > > - pq.emplace(30); > - pq.emplace(20); > - if (pq.size() != 3) return false; > - if (pq.top() != 30) return false; > + std::priority_queue<V, Cont, Cmp> pq6(std::move(pq3)); > + VERIFY( pq6.top() == pq5.top() ); > + VERIFY( pq6.size() == pq5.size() ); > + > + std::priority_queue<V, Cont, Cmp> > + pq10(std::begin(rg), std::end(rg), cmp); > + VERIFY( pq4.size() == 4 && pq4.top() == top_range ); > + > + std::priority_queue<V, Cont, Cmp> > + pq11(std::begin(rg), std::end(rg), cmp, v0); > + VERIFY( pq4.size() == 4 && pq4.top() == top_range ); > + > + std::priority_queue<V, Cont, Cmp> > + pq12(std::begin(rg), std::end(rg), cmp, std::move(v0)); > + VERIFY( pq4.size() == 4 && pq4.top() == top_range ); > + > + std::priority_queue<V, Cont, Cmp> pq14(alloc); > + VERIFY( pq14.empty() ); > + > + std::priority_queue<V, Cont, Cmp> pq15(cmp, alloc); > + VERIFY( pq15.empty() ); > + > + std::priority_queue<V, Cont, Cmp> pq16(cmp, v2, alloc); > + VERIFY( eq(pq16, {rg, 4}) ); > + > + std::priority_queue<V, Cont, Cmp> pq17(cmp, std::move(v2), alloc); > + VERIFY( eq(pq17, {rg, 4}) ); > + > + std::priority_queue<V, Cont, Cmp> pq18(pq12, alloc); > + VERIFY( pq18.size() == pq12.size()); > + > + std::priority_queue<V, Cont, Cmp> pq19(std::move(pq12), alloc); > + VERIFY( pq19.size() == pq18.size() ); > + return true; > +} > > +static_assert( ctor_tests<std::vector<int>>() ); > +static_assert( ctor_tests<std::vector<int>, std::greater<int>>() ); > +static_assert( ctor_tests<std::vector<int, SimpleAllocator<int>>>() ); > +static_assert( ctor_tests<std::deque<int>>() ); > +static_assert( ctor_tests<std::deque<int>, std::greater<int>>() ); > +static_assert( ctor_tests<std::deque<int, SimpleAllocator<int>>>() ); > + > +constexpr bool > +push_and_pop_test() > +{ > + std::priority_queue<int> a; > + a.push(2); > + a.push(4); > + VERIFY( a.top() == 4 ); > + a.pop(); > + VERIFY( a.top() == 2 ); > + a.pop(); > + VERIFY( a.empty() ); > + return true; > +} > +static_assert( push_and_pop_test() ); > + > +constexpr int swap_test() > +{ > + std::priority_queue<int> a,b; > + a.push(2); > + b.push(4); > + std::swap(a, b); > + VERIFY( a.top() == 4 ); > + VERIFY( b.top() == 2 ); > + return true; > +} > +static_assert (swap_test()); > + > +constexpr bool > +emplace_test() > +{ > + struct S > + { > + int foo; > + constexpr S(int i, int j) : foo{i + j} {} > + std::strong_ordering operator<=>(const S&) const = default; > + }; > + > + std::priority_queue<S> pq; > + pq.emplace(0, 0); > + pq.emplace(1, 0); > + VERIFY( pq.size() == 2 ); > + VERIFY( pq.top().foo == 1 ); > pq.pop(); > - if (pq.size() != 2) return false; > - if (pq.top() != 20) return false; > + VERIFY ( pq.top().foo == 0 ); > + return true; > +} > +static_assert( emplace_test() ); > + > +template<typename Range, typename Cont, typename Cmp> > +constexpr void > +do_range_tests(Cmp cmp = Cmp()) > +{ > + using V = typename Cont::value_type; > + using Alloc = typename Cont::allocator_type; > + using T = std::ranges::range_value_t<Range>; > > - std::priority_queue<int> pq2; > - pq2 = pq; > - if (pq2.size() != 2) return false; > - if (pq2.top() != 20) return false; > + Alloc alloc; > + T rg[] {2, 3, 5, 7, 11, 13}; > + > + auto top_range = std::ranges::max_element(rg, cmp); > + > + auto eq = [&](std::priority_queue<V, Cont, Cmp>& l, std::span<T> r) { > + if (l.size() != r.size()) > + return false; > + > + std::vector<T> s(r.begin(), r.end()); > + std::ranges::sort(s, cmp); > + for (auto const& v : s | std::views::reverse) { > + if (v != l.top()) > + return false; > + l.pop(); > + } > + return true; > + }; > + > + std::priority_queue<V, Cont, Cmp> > + pq1(std::from_range, Range(rg, rg+4), cmp); > + VERIFY( eq(pq1, {rg, 4}) ); > + > + std::priority_queue<V, Cont, Cmp> > + pq2(std::from_range, Range(rg, rg+5), alloc); > + VERIFY( eq(pq2, {rg, 5}) ); > + > + std::priority_queue<V, Cont, Cmp> > + pq3(std::from_range, Range(rg, rg+6), cmp, alloc); > + VERIFY( eq(pq3, {rg, 6}) ); > + > + std::priority_queue<V, Cont, Cmp> pq4; > + pq4.push_range(Range(rg, rg+6)); > + VERIFY( eq(pq4, {rg, 6}) ); > +} > + > +template<typename Range, typename Cont> > +constexpr void > +do_ranges_tests_b() > +{ > + do_range_tests<Range, Cont, std::less<>>(); > + do_range_tests<Range, Cont, std::greater<>>(); > +} > > - std::priority_queue<int> pq3; > - pq3.push(100); > - pq.swap(pq3); > - if (pq.size() != 1 || pq.top() != 100) return false; > - if (pq3.size() != 2 || pq3.top() != 20) return false; > +template<typename Cont> > +constexpr bool > +ranges_tests() { > + using T = typename Cont::value_type; > + do_ranges_tests_b< > + test_forward_range<T>, Cont>(); > + do_ranges_tests_b< > + test_forward_sized_range<T>, Cont>(); > + do_ranges_tests_b< > + test_sized_range_sized_sent<T, forward_iterator_wrapper>, Cont>(); > > - int arr[] = {50, 200, 10}; > - pq.push_range(arr); > - if (pq.size() != 4) return false; > - if (pq.top() != 200) return false; > + do_ranges_tests_b< > + test_input_range<T>, Cont>(); > + do_ranges_tests_b< > + test_input_sized_range<T>, Cont>(); > + do_ranges_tests_b< > + test_sized_range_sized_sent<T, forward_iterator_wrapper>, Cont>(); > > + do_ranges_tests_b< > + test_range<T, input_iterator_wrapper_nocopy>, Cont>(); > + do_ranges_tests_b< > + test_sized_range<T, input_iterator_wrapper_nocopy>, Cont>(); > + do_ranges_tests_b< > + test_sized_range_sized_sent<T, input_iterator_wrapper_nocopy>, > Cont>(); > return true; > } > > -static_assert(test_constexpr_priority_queue(), > - "constexpr priority_queue test failed!"); > +static_assert( ranges_tests<std::vector<int>>() ); > +static_assert( ranges_tests<std::vector<int, SimpleAllocator<int>>>() ); > +static_assert( ranges_tests<std::deque<int, SimpleAllocator<int>>>() ); > diff --git a/libstdc++-v3/testsuite/23_containers/queue/constexpr.cc > b/libstdc++-v3/testsuite/23_containers/queue/constexpr.cc > new file mode 100644 > index 00000000000..01dbc53b4ff > --- /dev/null > +++ b/libstdc++-v3/testsuite/23_containers/queue/constexpr.cc > @@ -0,0 +1,242 @@ > +// { dg-do compile { target c++26 } } > + > +#include <queue> > + > +#ifndef __cpp_lib_constexpr_queue > +# error "Feature test macro for __cpp_lib_constexpr_queue is missing in > <queue>" > +#elif __cpp_lib_constexpr_queue != 202502L > +# error "Feature test macro for __cpp_lib_constexpr_queue has wrong value > in <queue>" > +#endif > + > +#include <ranges> > +#include <functional> > +#include <vector> > +#include <numeric> > +#include <testsuite_hooks.h> > +#include <testsuite_iterators.h> > +#include <testsuite_allocator.h> > + > +using namespace __gnu_test; > + > +template<typename Cont> > +constexpr bool > +ctor_tests() > +{ > + using Tp = typename Cont::value_type; > + using Alloc = typename Cont::allocator_type; > + > + auto eq = [] (std::queue<Tp, Cont> l, std::span<Tp> r) { > + if (l.size() != r.size()) > + return false; > + > + std::vector<Tp> s(r.begin(), r.end()); > + for (auto v : s) { > + if (v != l.front()) > + return false; > + l.pop(); > + } > + return true; > + }; > + > + Cont c0; > + Alloc alloc0; > + > + std::queue<Tp, Cont> q1(c0); > + VERIFY( q1.size() == 0 && q1.empty() ); > + q1.push(1); > + q1.push(2); > + VERIFY( q1.size() == 2) ; > + > + Cont c1{1, 2}; > + std::queue<Tp, Cont> q2(c1); > + VERIFY ( q2 == q1 ); > + std::queue<Tp, Cont> q3(std::move(c1)); > + VERIFY ( q3 == q1 ); > + > + std::queue<Tp, Cont> q4(q1); > + std::queue<Tp, Cont> q5(std::move(q1)); > + VERIFY ( q4 == q5 ); > + > + Tp rg[4] = {2, 3, 5, 7}; > + std::queue<Tp, Cont> q6(std::begin(rg), std::end(rg)); > + VERIFY ( eq(q6, rg) ); > + > + VERIFY( q6.size() == std::size(rg)); > + VERIFY( q6.front() == 2 ); > + q6.pop(); > + VERIFY( q6.front() == 3 ); > + q6.pop(); > + VERIFY( q6.front() == 5 ); > + q6.pop(); > + VERIFY( q6.front() == 7 ); > + q6.pop(); > + > + std::queue<Tp, Cont> q7(alloc0); > + q7.push(1); > + q7.push(2); > + VERIFY( q7.size() == 2 ); > + > + Cont c2{1, 2}; > + std::queue<Tp, Cont> q8(c2, alloc0); > + VERIFY( q8 == q7 ); > + std::queue<Tp, Cont> q9(std::move(c2), alloc0); > + VERIFY( q9 == q7 ); > + VERIFY( c2.empty() ); > + > + std::queue<Tp, Cont> q10(q7, alloc0); > + VERIFY( q10 == q7 ); > + VERIFY( q10.size() == q7.size() ); > + VERIFY( q10.front() == q7.front() ); > + VERIFY( q10.back() == q7.back() ); > + > + std::queue<Tp, Cont> q11(std::move(q7), alloc0); > + VERIFY( q11 == q10 ); > + VERIFY( q11.size() == q10.size() ); > + VERIFY( q7.empty() ); > + > + std::queue<Tp, Cont> q12(std::begin(rg), std::end(rg), alloc0); > + VERIFY ( eq(q12, rg) ); > + VERIFY( q12.size() == std::size(rg)); > + VERIFY( q12.front() == 2 ); > + q12.pop(); > + VERIFY( q12.front() == 3 ); > + q12.pop(); > + VERIFY( q12.front() == 5 ); > + q12.pop(); > + VERIFY( q12.front() == 7 ); > + q12.pop(); > + > + std::queue<Tp, Cont> q13(std::from_range, rg); > + VERIFY( eq(q13, rg) ); > + std::queue<Tp, Cont> q14(std::from_range, rg, alloc0); > + VERIFY( eq(q14, rg) ); > + > + return true; > +} > +// TODO check list when avaialble > +static_assert( ctor_tests<std::deque<int>>() ); > +static_assert( ctor_tests<std::deque<int, SimpleAllocator<int>>>() ); > + > +template<typename Range, typename Cont> > +constexpr void > +do_ranges_tests_a() > +{ > + using Tp = typename Cont::value_type; > + typename Cont::allocator_type alloc; > + Tp a[] {2, 3, 5, 7}; > + > + auto eq = [&] (auto l, auto r) { > + if (l.size() != r.size()) > + return false; > + > + while (!l.empty()) { > + if (l.front() != r.front()) > + return false; > + l.pop(); > + r.pop(); > + } > + return true; > + }; > + > + std::queue<Tp, Cont> q1(std::from_range, Range(a, a+4)); > + std::queue<Tp> q2; > + q2.push_range(Range(a, a+4)); > + VERIFY( eq(q1, q2) ); > + > + std::queue<Tp, Cont> q3(std::from_range, Range(a, a+4), alloc); > + std::queue<Tp, Cont> q4(std::from_range, Range(a, a+4)); > + VERIFY( eq(q3, q4) ); > +} > + > +template<typename Cont> > +constexpr bool > +ranges_tests() > +{ > + using Tp = typename Cont::value_type; > + > + do_ranges_tests_a<test_forward_range<Tp>, Cont>(); > + do_ranges_tests_a<test_forward_sized_range<Tp>, Cont>(); > + do_ranges_tests_a< > + test_sized_range_sized_sent<Tp, forward_iterator_wrapper>, Cont>(); > + > + do_ranges_tests_a<test_input_range<Tp>, Cont>(); > + do_ranges_tests_a<test_input_sized_range<Tp>, Cont>(); > + do_ranges_tests_a< > + test_sized_range_sized_sent<Tp, forward_iterator_wrapper>, Cont>(); > + > + do_ranges_tests_a< > + test_range<Tp, input_iterator_wrapper_nocopy>, Cont>(); > + do_ranges_tests_a< > + test_sized_range<Tp, input_iterator_wrapper_nocopy>, Cont>(); > + do_ranges_tests_a< > + test_sized_range_sized_sent<Tp, input_iterator_wrapper_nocopy>, > Cont>(); > + return true; > +} > +// TODO check list when avaialble > +static_assert( ranges_tests<std::deque<int>>() ); > +static_assert( ranges_tests<std::deque<int, SimpleAllocator<int>>>() ); > + > +constexpr bool > +push_and_pop_test() > +{ > + std::queue<int> a; > + a.push(2); > + a.push(4); > + VERIFY( a.front() == 2 && a.back() == 4); > + a.pop(); > + VERIFY( a.front() == 4 && a.back() == 4); > + a.pop(); > + VERIFY( a.empty() ); > + return true; > +} > +static_assert( push_and_pop_test() ); > + > +constexpr bool > +swap_test() > +{ > + std::queue<int> a,b; > + a.push(1); > + b.push(2); > + std::swap(a, b); > + VERIFY( a.front() == 2 ); > + VERIFY( b.front() == 1 ); > + return true; > +} > +static_assert( swap_test() ); > + > +constexpr bool > +emplace_test() > +{ > + struct S > + { > + int foo; > + constexpr S(int i, int j) : foo{i + j} {} > + }; > + > + std::queue<S> a; > + const S& s = a.emplace(196883, 1); > + VERIFY( a.size() == 1 ); > + VERIFY( a.front().foo == 196884 ); > + return true; > +} > +static_assert( emplace_test() ); > + > +constexpr bool > +operator_test() > +{ > + std::queue<int> a, b; > + a.push(1); > + b.push(1); > + VERIFY( a == b ); > + VERIFY( a <= b ); > + VERIFY( a >= b ); > + b.pop(); > + b.push(2); > + VERIFY( a < b ); > + VERIFY( !(a > b) ); > + VERIFY( a <= b ); > + VERIFY( !(a >= b) ); > + VERIFY( a != b ); > + return true; > +} > +static_assert( operator_test() ); > diff --git a/libstdc++-v3/testsuite/std/format/ranges/adaptors.cc > b/libstdc++-v3/testsuite/std/format/ranges/adaptors.cc > index 649eea47f16..968ac00b63e 100644 > --- a/libstdc++-v3/testsuite/std/format/ranges/adaptors.cc > +++ b/libstdc++-v3/testsuite/std/format/ranges/adaptors.cc > @@ -6,8 +6,14 @@ > #include <stack> > #include <testsuite_hooks.h> > > +#ifdef __glibcxx_constexpr_format > +# define CONSTEXPR constexpr > +#else > +# define CONSTEXPR > +#endif > + > template<typename... Args> > -bool > +CONSTEXPR bool > is_format_string_for(const char* str, Args&&... args) > { > try { > @@ -22,7 +28,7 @@ is_format_string_for(const char* str, Args&&... args) > #define WIDEN(S) WIDEN_(CharT, S) > > template<template<typename Tp> class Adaptor> > -void > +CONSTEXPR void > test_format_string() > { > Adaptor<int> q; > @@ -41,7 +47,7 @@ struct NoFormat > struct MutFormat > { > MutFormat() = default; > - MutFormat(int p) : x(p) {} > + CONSTEXPR MutFormat(int p) : x(p) {} > > int x; > friend auto operator<=>(MutFormat, MutFormat) = default; > @@ -52,7 +58,8 @@ struct std::formatter<MutFormat, CharT> > : std::formatter<int, CharT> > { > template<typename Out> > - Out format(MutFormat& mf, basic_format_context<Out, CharT>& ctx) const > + CONSTEXPR Out > + format(MutFormat& mf, basic_format_context<Out, CharT>& ctx) const > { return std::formatter<int, CharT>::format(mf.x, ctx); } > }; > > @@ -68,7 +75,7 @@ constexpr auto std::format_kind<NotFormattableCont<T>> > > template<typename CharT, > template<typename Tp, typename Cont = std::vector<Tp>> class > Adaptor> > -void > +CONSTEXPR void > test_output() > { > const std::vector<int> v{3, 2, 1}; > @@ -133,7 +140,7 @@ test_output() > } > > template<template<typename Tp, typename Cont = std::vector<Tp>> class > Adaptor> > -void > +CONSTEXPR void > test_adaptor() > { > test_format_string<Adaptor>(); > @@ -145,7 +152,7 @@ test_adaptor() > } > > template<typename CharT> > -void > +CONSTEXPR void > test_compare() > { > const std::vector<int> v{3, 2, 1}; > @@ -157,9 +164,20 @@ test_compare() > VERIFY( res == WIDEN("[1, 2, 3]") ); > } > > -int main() > +CONSTEXPR bool > +test_all() > { > test_adaptor<std::queue>(); > test_adaptor<std::priority_queue>(); > test_compare<char>(); > + return true; > +} > + > +#ifdef __glibcxx_constexpr_format > + static_assert(test_all()); > +#endif > + > +int main() > +{ > + test_all(); > } > -- > 2.55.0 > >